noname/character/hearth.js

import { lib, game, ui, get, ai, _status } from '../noname.js';
game.import('character', function () {
	return {
		name:'hearth',
		character:{
			hs_jaina:['female','wei',3,['huopu','aoshu','bingjia']],
			hs_lrexxar:['male','shu',4,['yushou']],
			hs_wuther:['male','qun',4,['fengxian','rejieming']],
			hs_jgarrosh:['male','shu',4,['zhanhou','qiangxi']],
			hs_malfurion:['male','wu',4,['jihuo']],
			hs_guldan:['male','wei',3,['moxie','fuhua','hongxi']],
			hs_anduin:['male','qun',3,['shengguang','shijie','anying']],
			hs_sthrall:['male','wu',4,['tuteng','guozai','zuling']],
			hs_waleera:['female','shu',3,['jianren','mengun','wlianji']],

			hs_medivh:['male','wei',3,['jingxiang','zuzhou','mdzhoufu']],
			hs_alleria:['female','wu',3,['fengxing','xinliegong']],
			hs_magni:['male','shu',4,['zhongjia','dunji']],
			hs_liadrin:['female','shu',4,['xueren']],
			hs_morgl:['male','wu',3,['s_tuteng']],
			hs_khadgar:['male','shu',3,['midian','fuwen','jinzhou']],
			hs_tyrande:['female','wei',3,['yuelu','xingluo']],

			hs_neptulon:['male','wu',4,['liechao','qingliu']],
			hs_wvelen:['male','qun',3,['shengyan','xianzhi']],
			hs_antonidas:['male','wei',3,['yanshu','bingshuang']],
			hs_alakir:['male','wei',3,['fengnu','shengdun']],
			hs_zhouzhuo:['male','qun',4,['yiwen']],
			hs_yngvar:['male','qun',3,['huanwu']],
			hs_bchillmaw:['male','wei',5,['hanshuang','bingshi']],
			hs_malorne:['male','wu',3,['enze','chongsheng']],
			hs_malygos:['male','wei',4,['malymowang']],
			hs_xuefashi:['male','wei',2,['liehun','xjumo']],
			hs_loatheb:['male','wu',5,['duzhang']],
			hs_trueheart:['female','qun',3,['qianghuax']],
			hs_sainaliusi:['male','wu',4,['chongsheng','yulu']],
			hs_lrhonin:['male','wei',4,['bingyan','yufa']],
			hs_bolvar:['male','wei',4,['yuanzheng','bzhuiji']],
			hs_fuding:['male','wei',4,['shengdun','fbeifa']],
			hs_xuanzhuanjijia:['male','shu',2,['jixuan']],
			hs_ysera:['female','wu',4,['bimeng']],
			hs_alextrasza:['female','shu',5,['fushi']],
			hs_nozdormu:['male','qun',5,['shixu']],
			hs_sapphiron:['male','wei',4,['bingdong','stuxi']],
			hs_kchromaggus:['male','wei',4,['fenlie']],
			hs_lreno:['male','shu',4,['tanmi']],
			hs_brann:['male','shu',3,['qianghua','mashu']],
			hs_finley:['male','wu',3,['maoxian']],
			hs_kcthun:['male','qun',4,['luanji','xianji']],
			hs_anomalus:['male','wei',4,['mobao']],
			hs_blingtron:['male','shu',3,['zengli','xiubu']],
			hs_yogg:['male','wu',4,['qianhou']],
			hs_xialikeer:['female','shu',3,['duxin']],
			hs_pyros:['female','shu',2,['pyuhuo']],
			hs_kalimosi:['male','wu',4,['kqizhou']],

			hs_zhishigushu:['male','shu',4,['jiaohui']],
			hs_zhanzhenggushu:['male','wei',6,['biri']],
			hs_ronghejuren:['male','shu',8,['ronghuo']],
			hs_shanlingjuren:['male','wu',8,['luoshi']],
			hs_aedwin:['male','wu',4,['lianzhan']],
			hs_mijiaojisi:['female','wu',3,['kuixin']],
			hs_huzhixiannv:['female','wu',3,['jingmeng','qingliu']],
			hs_totemic:['male','wu',3,['peiyu']],
			hs_wujiyuansu:['male','wei',3,['hswuji']],
			hs_xsylvanas:['female','qun',3,['busi','xshixin','xmojian']],
			hs_siwangzhiyi:['male','qun',12,['mieshi']],
			hs_bilanyoulong:['male','wei',4,['lingzhou']],
			hs_jinglinglong:['male','wu',3,['moyao']],
			hs_ruanniguai:['male','wu',3,['nianfu','xiaorong']],
			hs_hudunren:['male','shu',2,['hhudun']],
			hs_nate:['male','wu',4,['chuidiao']],
			hs_jiaziruila:['male','wu',4,['hannu']],
			hs_shifazhe:['male','wei',3,['shifa']],
			hs_lafamu:['male','shu',4,['xieneng']],
			hs_yelise:['female','wei',3,['xunbao','zhuizong']],
			hs_jiawodun:['male','wu',4,['jinhua']],

			hs_fandral:['male','shu',4,['nuyan','chouhuo']],
			hs_hallazeal:['male','wei',4,['shengteng','yuansu']],
			hs_enzoth:['male','qun',4,['mengye']],
			hs_walian:['male','shu',4,['wzhanyi']],
			hs_pengpeng:['male','qun',4,['yindan']],
			hs_yashaji:['male','qun',4,['ysjqisha']],
			// hs_wolazi:['male','wei',3,[]],

			hs_tanghangu:['male','shu',5,['zhongji']],
			hs_aya:['female','wu',3,['ayuling','qingzun']],
			hs_barnes:['male','shu',4,['hsnitai']],
			// hs_nuogefu:['male','wei',3,[]],
			hs_kazhakusi:['male','shu',3,['lianjin']],
			// hs_lazi:['male','wei',3,[]],
			hs_shaku:['male','wei',3,['shouji']],
			hs_laxiao:['male','shu',3,['hsguimou','yingxi','hlongyi']],
			// hs_xiangyaqishi:['male','wei',3,[]],
			// hs_fenjie:['male','shu',3,['hsguimou','yingxi']],
			hs_mojinbaozi:['male','wei',3,['jingcu','shengzhang']],
			hs_shuiwenxuejia:['male','wu',3,['kekao']],
			hs_shizugui:['male','wu',3,['szbianshen']],
			hs_hemite:['male','wu',6,['zhuilie']],
			hs_laila:['male','wu',3,['lieyang']],

			hs_selajin:['male','shu',3,['qianfu','shimo']],
			hs_bannabusi:['male','wu',14,['qingtian']],
			hs_amala:['female','wu',3,['azaowu','shouwang']],
			hs_yinggencao:['male','wu',3,['lieqi']],

			hs_zhihuanhua:['female','wei',3,['huanjue']],
			hs_shirencao:['male','wu',3,['srjici']],
			hs_kaituozhe:['female','wu',3,['tansuo','yinzong']],

			hs_fachaotuteng:['male','wei',3,['xiyong']],
			hs_huolituteng:['male','wei',3,['hllingxi']],
			hs_manyututeng:['male','wu',3,['zhaochao']],
			hs_tgolem:['male','wu',4,['xinwuyan','guozaix']],

			hs_heifengqishi:['male','qun',4,['hstianqi']],
			// hs_yuhuozhe:['male','qun',4,['hstianqi']],
			// hs_wuyaowang:['male','qun',4,['hstianqi']],
			// hs_aerfusi:['male','qun',4,['hstianqi']],
			// hs_baiguyoulong:['male','qun',4,['hstianqi']],
			hs_yangyanwageli:['female','qun',3,['hspuzhao','hsyanxin']],

			hs_aiqinvyao:['female','qun',4,['nsaiqi','nsbeiming']],

			hs_yelinlonghou:['female','qun',4,['ylyuchu']],
			hs_yelinchulong:["male","qun",1,[],['unseen']],
			hs_ashamoer:['female','wei',3,['asyouzhang']],
			hs_fengjianhuanfengzhe:['male','wei',3,['tuteng','huanfeng']],
			hs_taisi:['female','wei',3,['hsxingyi','hshuanling']],
			// hs_bingshuangnvwang:['female','wei',3,['hsshuangshi','hs']]

			hs_hajiasha:['female','wu',3,['zhoujiang','muyin']],
			hs_tuoqi:['female','shu',3,['tqchuanyue']],
			hs_siwangxianzhi:['male','wei',3,['hualing','yibian']],
			hs_xukongzhiying:['female','qun',3,['wxuying']],

			hs_duyaxinshi:['male','wei',3,['hshuanyu']],
		},
		characterIntro:{
			hs_jaina:'戴林·普罗德摩尔之女。 在吉安娜成年早期，她致力于阻止将引发第三次战争的天灾瘟疫传播，当战况加剧后，吉安娜获得了新部落大酋长萨尔的信任，成为团结艾泽拉斯各族携手对抗燃烧军团的关键人物。当战争结束后，吉安娜管理着塞拉摩岛，致力于促进部落与联盟间的关系。吉安娜的和平立场与性格在接任萨尔成为部落大酋长的加尔鲁什·地狱咆哮以一颗魔法炸弹夷平塞拉摩后改变了。身为肯瑞托的新领袖，她拥有让加尔鲁什为他酿成的惨剧付出血的代价的权力与决心。',
			hs_lrexxar:'作为部落最伟大的英雄之一，雷克萨本是兽人与食人魔结合的产物。他从小在德拉诺的莫克纳萨氏族长大。流血冲突和以及来自部落内部的陷害慢慢消磨了雷克萨为部落而战的热情，最终导致他独自出走。雷克萨与他的新伙伴们，包括巨熊米莎，消失在艾泽拉斯世界。在第三次大战中，雷克萨结识了年轻的酋长萨尔，后者重建部落的热情令他大受启发。奥格瑞玛建成之后，部落勇士的称号也传回了他在外域（德拉诺世界的残片）的家乡。如今，雷克萨依然随时准备着为全新的部落——他真正的人民——效劳。',
			hs_wuther:'乌瑟尔·光明使者是白银之手骑士团的领袖，同时也是大主教阿隆索斯·法奥之徒。当暴风城被兽人攻陷，莱恩国王遇害之后，乌瑟尔跟随法奥和安度因·洛萨同往洛丹伦王国寻求援助。鉴于艾泽拉斯战役的教训和迫在眉睫的兽人的威胁，法奥决定重建洛丹伦王国的圣教组织，并由他的学徒兼助手乌瑟尔来全权负责。这就是后世著名的“白银之手”骑士团。',
			hs_jgarrosh:'前部落酋长。什出生于德拉诺的兽人家园，他的成长未曾受侵略艾泽拉斯兽人身上流淌着的恶魔之血所污染。虽然自身并未受腐化影响，但加尔鲁什始终活在身世的阴影之下。',
			hs_malfurion:'在德鲁伊的守护神、半神塞纳留斯的指引下，玛法里奥·怒风千年以来一直保护着暗夜精灵不受恶魔侵扰。在上古之战中，玛法里奥与其他英雄一起，为了保护艾泽拉斯的所有生命，抵抗过可怕的燃烧军团，随后玛法里奥和其他德鲁伊在翡翠梦境中探索了数百年之久。在第三次大战中，泰兰德唤醒了玛法里奥，请他再次协助抵抗燃烧军团。玛法里奥离开暗夜精灵主城达纳苏斯，并召集他的德鲁伊同伴再次拯救艾泽拉斯，并组成了特别部队，阻止了邪恶的炎魔拉格纳罗斯的入侵。随着灭世者的死亡，彻底觉醒的玛法里奥与泰兰德终于团聚并一同支持联盟的行动。',
			hs_guldan:'在兽人的家乡德拉诺，古尔丹生于影月氏族一个偏远的村庄，由于残疾，他被族人所抛弃。在村中萨满的指引下，他来到了纳格兰的元素王座，祈求元素指引他的道路，可最终，就连元素都放弃了他。但是，一股古老而可怕的黑暗势力向他伸出了“援手”——燃烧军团。得到了恶魔之力的古尔丹成为了史上第一位术士，他回到了抛弃自己的村庄，杀死了所有他曾经的族人，也“回报”了那位指引他的萨满以“感激”。现在，古尔丹是燃烧军团的先驱者，竭力使终极的毁灭降临艾泽拉斯。',
			hs_anduin:'蒂芬与瓦里安·乌瑞恩之子，安度因·莱恩·乌瑞恩是暴风城的王位继承人。数年前，当他的父亲失踪后，年轻的安度因便加冕暴风城国王。但尚处年幼的他无法胜任王国事务，交由联盟中德高望重的圣骑士伯瓦尔·弗塔根公爵代为执政。当国王瓦里安回归并重掌王位后，王子开始专注于心灵和外交的修炼，环游艾泽拉斯来了解如何才能治愈饱受战争摧残的大地和灵魂。安度因心灵善良且富有同情心，不同于他父亲战士出身的莽撞，令他与德莱尼的先知维伦，甚至一些部落成员结下不解之缘。',
			hs_sthrall:'“萨尔”是兽人古伊尔年轻时候的绰号，他的父母因反对古尔丹被杀，人类中士埃德拉斯·布莱克摩尔发现了襁褓中的他，并计划将他培育成自己野心计划的重要棋子；而萨尔，正是奴隶之意。古伊尔摆脱控制后踏上寻根之旅，最后从先祖的萨满信仰中寻得了智慧。他重整了部落，成为大酋长并领导他的人民在贫瘠之地上定居。萨尔领导部落通过了一连串的试炼，当死亡之翼重返人间并撕裂世界，萨尔从部落大酋长的位置退下，加入了大地之环这个强大的萨满组织，企图平息元素并阻止灭世者。萨尔选择加尔鲁什·地狱咆哮做为继任者，然而这个决定一直困扰着他，因为新任大酋长却把部落带上了内乱的歧途。',
			hs_waleera:'瓦莉拉·萨古纳尔在竞技场角斗士上认识瓦里安和暗夜精灵德鲁伊布罗尔·熊皮组成"竞技场"角斗士三人组。尽管她拒绝在部落和联盟的战争中站队，这位血精灵仍然不止一次挽救过暴风城国王的性命。',
			hs_medivh:'卡拉赞领主，最后的守护者。黑暗泰坦萨格拉斯在被他的母亲艾格文击败后，悄悄潜入了她的身体，并最终侵入尚未出生的麦迪文体内。随着麦迪文的成长，萨格拉斯的黑暗力量渐渐显露出来。麦迪文与古尔丹的影子议会合力，打开了连接两个世界的黑暗之门，部落军队得以大举进入艾泽拉斯。最终，得于卡德加和加罗娜的相助，洛萨率众突入卡拉赞，击败了邪恶的守护者麦迪文。',
			hs_alleria:'风行者三姐妹的大姐。奥蕾莉亚·风行者的成名战始于巨魔战争中期，为了保卫家园，她击退了数之不尽的巨魔。 在第二次大战中，奎尔萨拉斯边陲地带被部落烧成了灰烬，但她和两个妹妹：希尔瓦娜斯和温蕾萨却幸存了下来。在兽人耐奥祖重新打开了德拉诺和艾泽拉斯之间的通路后，奥蕾莉亚参加了远征军，穿越传送门前往德拉诺。在远征军毁掉德拉诺端的黑暗之门之前，德拉诺开始四分五裂，选征军择了一扇新的传送门，并穿越了它，此后再无音讯。',
			hs_magni:'麦格尼是历史上最著名的矮人之一，作为一个统治者，他展现出了无比的勇气和慷慨无私的品质。作为铁炉堡的统治者，麦格尼·铜须国王总是将人民的需求置于自身所求之前。因此，当大地裂变震撼、颠覆了艾泽拉斯时，麦格尼执行了一个古老的仪式，试图与大地沟通以了解这次事件的起源。但麦格尼还没找到答案，就被变成一具了无生息的钻石雕像。',
			hs_liadrin:'曾是一名高等精灵牧师，现在是血骑士的领袖。莉亚德琳曾认为血精灵永远也无法偿清他们对穆鲁所犯下的错误，但维纶却使用穆鲁的精华净化了太阳之井，让太阳之井变成了一个满溢出圣光能量的巨大能量源。莉亚德琳不愿回到触及她心中伤口的奎尔萨拉斯去，独自幽居在幽魂之地中，但她却总是收到有人匿名送来（其实照顾她的正是对她恋心依旧的洛瑟玛·塞隆）的绿色魔法水晶，以缓解她同所有高等精灵一样在失去太阳之井后不能自拔的魔瘾。',
			hs_morgl:'一名鳄鱼人大地之环先知。鳄鱼人自上古时代就生活于索拉查盆地，可以说是最原始的鱼人种族，他们是索拉查盆地－这个泰坦生态实验场的第一批居民之一，虽然他们的相貌的确不敢恭维，但他们却默默的守护着这片区域，守护着泰坦创世时所留下的科技成果。 然而，他们的智力仍保持于原始崇拜的地步，他们基本不在意这些泰坦科技的重要性。',
			hs_khadgar:'大法师卡德加曾是守护者麦迪文手下的年轻学徒，亲身经历了前两次战争。当他发现麦迪文的计划，了解到麦迪文企图打开德拉诺传送门将受恶魔控制的兽人大军释放到艾泽拉斯之后，卡德加协助打败了他的导师。在战斗中，卡德加中了一个可怕的法术，整个人急剧地衰老。虽然身体变得年迈脆弱，但他的心智依然清醒敏锐。现在卡德加致力于联合艾泽拉斯的所有力量来对抗燃烧军团的入侵，而且要一劳永逸地解决古尔丹。',
			hs_tyrande:'作为月光之下最出色的猎手，女神艾露恩的选民，泰兰德已经领导暗夜精灵奋战了数个世纪。泰兰德出生于数千年前，与玛法里奥·怒风和伊利丹·怒风一共长大。她响应了暗夜精灵的月亮女神的追随者们，艾露恩姐妹会的召唤，成为一名新手女祭司。而怒风兄弟则走上了另一条道路。但当燃烧军团降临艾泽拉斯，他们的命运又再次发生了交集。',

			hs_neptulon:'耐普图隆被称为"猎潮者"。他是四大元素领主之一。他和拉格纳罗斯能够联手为你提供最好的桑拿服务。',
			hs_wvelen:'他被逐出他的家园。他兄弟们都变成了邪恶的主宰......但是除此之外，他好像也没有什么别的可以抱怨的了。',
			hs_antonidas:'肯瑞托的首席法师，达拉然最伟大的子民，安东尼达斯在被巫妖王阿尔萨斯杀死之前，曾是吉安娜的导师。. 预言者警告他必须迁移到西方去, 但安东尼达斯没有注意。最终导致了自己和达拉然的毁灭。',
			hs_alakir:'他是四大元素领主中最弱的一个。而另外三个总是会提醒他这一点。',
			hs_zhouzhuo:'游学者周卓整理并分享有关潘达利亚大陆的轶事，但他最喜欢的故事，是乔伊和菲比一起外出旅行发生的事情。',
			hs_yngvar:'唤雾者召来的不光有雾，还有霾。记得戴口罩。',
			hs_bchillmaw:'冰喉一心想要毁掉锦标赛。至于原因，都是因为那些吵闹个不停地熊孩子们！',
			hs_malorne:'玛洛恩之所以讨厌恶魔，是因为他不理解为什么这些又脏又臭的生物会长着和他一样的蹄子。',
			hs_malygos:'玛里苟斯憎恨凡人使用魔法。那会让他气急败坏！',
			hs_xuefashi:'他负责每年一度的血色修道院献血运动！',
			hs_loatheb:'洛欧塞布原本只是头普通的沼泽兽。从它身上的变化可见矿业和农业给自然带来了多大的破坏。',
			hs_trueheart:'英雄技能2.0升级版，面向所有职业。',
			hs_sainaliusi:'“当它们还是种子的时候，我便认识它们了……”',
			hs_lrhonin:'无主之人，无冕之王。',
			hs_bolvar:'在伯瓦尔身上的冰融化之后，他受邀接受了采访。在采访中他对艾泽拉斯全球气候变暖现象表达了深深的忧虑。',
			hs_fuding:'如果你还没听过《提里奥·弗丁主题曲》，那是因为它还没被谱写出来。',
			hs_xuanzhuanjijia:'这个打蛋器可好用了。',
			hs_ysera:'伊瑟拉统治翡翠梦境。所谓翡翠梦境，究竟只是现实世界的绿色朦胧倒影，还是其它别的什么地方？',
			hs_alextrasza:'生命的缚誓者阿莱克丝塔萨给所有人带来生命和希望。除了死亡之翼。除了玛里苟斯。除了耐克鲁斯。',
			hs_nozdormu:'没时间写什么背景描述了。',
			hs_kchromaggus:'当两个头都无法说服对方晚餐到底吃什么的时候，它通常都会去拉面店解决问题。',
			hs_lreno:'雷诺曾四次荣获由探险者协会颁发的“年度最佳服饰奖”。',
			hs_brann:'自从铁炉堡的国王麦格尼华丽登场后，布莱恩也想像哥哥那样出一套英雄皮肤。',
			hs_finley:'除了正常的官方用语外，他还精通14种鱼人方言。',
			hs_kcthun:'克苏恩最讨厌的一张牌，就是圣骑士的奥秘“以眼还眼”。',
			hs_anomalus:'阿诺玛鲁斯是由混乱的奥术能量所组成的，所以消灭它存在相当大的风险。',
			hs_blingtron:'启动布林顿，让所有参加派对的人都嗨起来！',
			hs_yogg:'你死期到了……死期到了……期到了……到了……了！',
			hs_xialikeer:'什么！螳螂妖给你的东西你也敢喝？真是自寻死路。',
			hs_zhishigushu:'去吧，把你的名字刻在树皮上。',
			hs_zhanzhenggushu:'年轻的暗夜精灵们喜欢一种叫做“谁能让战争古树站起来”的游戏。如果在它起身的时候你被踩死了，你还是输了。',
			hs_ronghejuren:'无数初次来到熔火之心的冒险者倒在他滚烫的脚掌之下。',
			hs_shanlingjuren:'他的妈妈说，他只是骨架比较大而已。',
			hs_aedwin:'他领导石匠协会重建了暴风城，而当贵族们拒绝支付工钱的时候，他将领导迪菲亚兄弟会，嗯，拆掉暴风城。',
			hs_mijiaojisi:'你绝不知道谁在为这个秘密组织效劳...',
			hs_huzhixiannv:'传闻她手中持的便是亚瑟王的断钢剑。',
			hs_totemic:'事实证明海象人对于图腾的样式一点都不挑剔。',
			hs_xsylvanas:'没有人比女王更渴望真正地死去。',
			hs_siwangzhiyi:'死亡之翼原本是高贵的巨龙奈萨里奥，他发疯之后制造了艾泽拉斯的大灾变，但最终被击败。子不教，父之过？',
			hs_bilanyoulong:'它们本来应该是宝蓝色或是蔚蓝色，但这几个颜色显得有点太耀眼了。',
			hs_jinglinglong:'可爱至极，免疫魔法，不会在毯子上撒尿。真是完美的宠物！',
			hs_nate:'纳特·帕格是艾泽拉斯最棒的钓手！他发明了自动鱼竿3000型，伸缩鱼竿3000型，以及电气自动诱捕器2099型（仍在测试中）。',
			hs_jiaziruila:'祖尔法拉克队是本届巨魔世界杯的夺冠热门球队，他们的队旗上描绘着令人望而生畏的多头蛇加兹瑞拉。',
			hs_lafamu:'他在搜集神器方面很有一手，只不过都是从别人的博物馆里抢来的。',
			hs_yelise:'作为团队里的绘图师，伊莉斯现在最主要的工作就是拼凑出完整的“黄金猿藏宝图”。',
			hs_fandral:'每当范达尔·鹿盔举起酒杯，并以“想当年我在种世界之树的时候……”为开场白在那老调重弹时，众酒客便会作鸟兽散。',
			hs_hallazeal:'根据能量守恒定律，你损失的生命值最终会转移到我身上。',
			hs_walian:'联盟的统治者！安杜因的父亲！同时他还喜欢玩竞技模式，场均12胜。',
			hs_tanghangu:'作为污手党家族的主心骨，汉有时真想把愚钝的古扫地出门，但他没法这么做。',
			hs_aya:'别看艾雅年纪轻，她可是玉莲帮的实际掌权者。看似天真活泼的少女，转眼之间就会召唤出魔像大军，将敌人统统碾碎！',
			hs_kazhakusi:'暗金教在此严正声明，卡扎库斯教主并非巨龙，也从未染指过违禁药水。任何公开污蔑暗金教与卡扎库斯教主本人的言论，必将遭受法律与龙息药水的严惩。',
			hs_shaku:'艾雅曾调查过沙库尔，看看他有没有私藏了什么好东西。',
			hs_laxiao:'什么？身为死亡之翼的儿子，拉西奥居然不是龙牌？你似乎知道的太多了…',
		},
		characterTitle:{
			hs_aiqinvyao:'#bSnonamekill'
		},
		perfectPair:{
			hs_sthrall:['hs_totemic','hs_alakir','hs_neptulon','hs_yngvar'],
			hs_anduin:['hs_wvelen','hs_mijiaojisi'],
			hs_jaina:['hs_antonidas'],
			hs_malfurion:['hs_malorne'],
		},
		/** @type { importCharacterConfig['skill'] } */
		skill:{
			hshuanyu:{
				trigger:{player:'damageEnd'},
				frequent:true,
				content(){
					if(!lib.characterPack.hearth){
						player.draw();
						return;
					}
					var list=[];
					for(var i=0;i<lib.cardPack.mode_derivation.length;i++){
						var name=lib.cardPack.mode_derivation[i];
						var info=lib.card[name];
						if(info.gainable==false||info.destroy) continue;
						if(lib.characterPack.hearth[info.derivation]){
							list.push(name);
						}
					}
					if(!list.length){
						player.draw();
					}
					else{
						player.discoverCard(list);
					}
				},
				ai:{
					threaten:0.8,
					maixie:true,
					maixie_hp:true,
					effect:{
						target(card,player,target){
							if(get.tag(card,'damage')){
								if(player.hasSkillTag('jueqing',false,target)) return [1,-2];
								if(!target.hasFriend()) return;
								if(target.hp>=4) return [1,get.tag(card,'damage')*2];
								if(target.hp==3) return [1,get.tag(card,'damage')*1.5];
								if(target.hp==2) return [1,get.tag(card,'damage')*0.5];
							}
						}
					}
				}
			},
			wxuying:{
				trigger:{player:'phaseBegin'},
				forced:true,
				content(){
					'step 0'
					var cards=player.getCards('h',function(card){
						return card.name=='hsfashu_anyingjingxiang'||card._wxuying;
					});
					if(cards.length){
						player.lose(cards)._triggered=null;
					}
					'step 1'
					var card=game.createCard('hsfashu_anyingjingxiang');
					card._modUseful=function(){
						return 7;
					};
					card._modValue=function(){
						return 7;
					};
					player.gain(card,'gain2');
				},
				subSkill:{
					lose:{
						trigger:{player:'loseAfter'},
						silent:true,
						content(){
							for(var i=0;i<trigger.cards.length;i++){
								if(trigger.cards[i]._wxuying){
									player.storage.wxuying=trigger.cards[i];
									delete trigger.cards[i]._wxuying;
								}
							}
						}
					},
					change:{
						trigger:{player:['useCard','respond']},
						silent:true,
						content(){
							var cards=player.getCards('h',function(card){
								return card.name=='hsfashu_anyingjingxiang'||card._wxuying;
							});
							for(var i=0;i<cards.length;i++){
								cards[i].init(trigger.card);
								cards[i].classList.add('glow');
								cards[i]._wxuying=true;
							}
						}
					},
					hide:{
						trigger:{player:['useCard','respond']},
						forced:true,
						priority:-1,
						filter(event,player){
							return event.cards.includes(player.storage.wxuying);
						},
						content(){
							if(_status.currentPhase==player){
								player.draw();
							}
							else{
								player.tempHide();
							}
							delete player.storage.wxuying;
						}
					},
					clear:{
						trigger:{player:'phaseAfter'},
						silent:true,
						content(){
							delete player.storage.wxuying;
						}
					}
				},
				group:['wxuying_change','wxuying_hide','wxuying_lose','wxuying_clear']
			},
			buwendingyibian_ai1:{},
			buwendingyibian_ai2:{},
			buwendingyibian_lose:{
				trigger:{global:'phaseAfter'},
				silent:true,
				content(){
					var cards=player.getCards('h',function(card){
						return card.name=='hsfashu_buwendingyibian'&&card._destroy;
					});
					if(cards.length){
						player.lose(cards)._triggered=null;
					}
				}
			},
			yibian:{
				trigger:{player:'phaseUseBegin'},
				forced:true,
				filter(event,player){
					return !player.countCards('h','hsfashu_buwendingyibian');
				},
				content(){
					player.gain(game.createCard('hsfashu_buwendingyibian'),'gain2');
				}
			},
			hualing:{
				enable:'phaseUse',
				round:3,
				skillAnimation:true,
				filterTarget(card,player,target){
					return target!=player;
				},
				content(){
					'step 0'
					player.chooseSkill(target,function(info,skill){
						return !player.hasSkill(skill);
					});
					'step 1'
					if(result.bool){
						var skill=result.skill;
						player.addAdditionalSkill('hualing',skill);
						player.popup(skill);
						player.markSkillCharacter('hualing',target.name,get.skillTranslation(skill,player),get.skillInfoTranslation(skill));
					}
					'step 2'
					var rank=get.rank(target,true);
					var list=get.gainableCharacters(true);
					var choice=[];
					for(var i=0;i<list.length;i++){
						if(get.rank(list[i],true)==rank+1){
							choice.push(list[i]);
						}
					}
					if(!choice.length){
						for(var i=0;i<list.length;i++){
							if(get.rank(list[i],true)==rank){
								choice.push(list[i]);
							}
						}
					}
					if(choice.length){
						var hp=target.hp;
						var name=choice.randomGet();
						target.reinit(target.name,name);
						target.hp=Math.min(hp,target.maxHp);
						target.update();
						game.triggerEnter(target);
					}
				},
				ai:{
					order:8,
					result:{
						target(player,target){
							return 1/(get.rank(target,true)+1);
						}
					}
				}
			},
			muyin:{
				trigger:{player:'loseEnd'},
				forced:true,
				filter(event,player){
					if(player.countCards('h')) return false;
					for(var i=0;i<event.cards.length;i++){
						if(event.cards[i].original=='h') return true;
					}
					return false;
				},
				content(){
					player.tempHide();
				},
				ai:{
					noh:true,
					skillTagFilter(player,tag){
						if(tag=='noh'){
							if(player.countCards('h')!=1) return false;
						}
					}
				}
			},
			tqchuanyue:{
				trigger:{player:'phaseBeginStart'},
				forced:true,
				ai:{
					threaten:1.5
				},
				content(){
					var list=[
						'oldhanshuang','oldyanshu','oldfbeifa','oldmalymowang','oldfenlie',
						'oldshifa','oldfushi','oldhuanjue','oldzhanhou','oldduxin',
						'oldenze','oldyulu',
					];
					var map={
						oldhanshuang:'hs_bchillmaw',
						oldyanshu:'hs_antonidas',
						oldfbeifa:'hs_fuding',
						oldmalymowang:'hs_malygos',
						oldfenlie:'hs_kchromaggus',
						oldshifa:'hs_shifazhe',
						oldfushi:'hs_alextrasza',
						oldhuanjue:'hs_zhihuanhua',
						oldzhanhou:'hs_jgarrosh',
						oldduxin:'hs_xialikeer',
						oldenze:'hs_malorne',
						oldyulu:'hs_sainaliusi'
					};
					for(var i=0;i<list.length;i++){
						var skill=list[i];
						if(!lib.skill[skill]||player.hasSkill(skill)||get.is.empty(lib.skill[skill])){
							list.splice(i--,1);
						}
					}
					if(list.length){
						var skill=list.randomGet();
						player.addAdditionalSkill('tqchuanyue',skill);
						player.popup(skill);
						player.flashAvatar('tqchuanyue',map[skill]);
						player.markSkillCharacter('tqchuanyue',map[skill],get.skillTranslation(skill),get.skillInfoTranslation(skill));
					}
				}
			},
			oldhuanjue:{
				trigger:{global:'useCard1'},
				usable:1,
				filter(event,player){
					if(event.targets.length!=1) return false;
					if(event.player==player) return false;
					if(player!=event.targets[0]) return false;
					for(var i=0;i<lib.inpile.length;i++){
						var info=lib.card[lib.inpile[i]];
						if(info.multitarget) continue;
						if(lib.filter.targetEnabled2({name:lib.inpile[i]},event.player,player)){
							return true;
						}
					}
					return false;
				},
				check(event,player){
					return get.effect(player,event.card,event.player,player)<0;
				},
				prompt2(event,player){
					return '发现一张牌代替'+get.translation(event.player)+'对你使用的'+get.translation(event.card);
				},
				autodelay:true,
				content(){
					'step 0'
					var list=[],list1=[],list2=[];
					for(var i=0;i<lib.inpile.length;i++){
						var info=lib.card[lib.inpile[i]];
						if(info.multitarget) continue;
						if(lib.filter.targetEnabled2({name:lib.inpile[i]},trigger.player,trigger.targets[0])){
							var cardinfo=[trigger.card.suit||'',trigger.card.number||'',lib.inpile[i]];
							list1.push(cardinfo);
							if(info.type!='equip'){
								list2.push(cardinfo);
							}
						}
					}
					var equipped=false;
					for(var i=0;i<3;i++){
						if(equipped&&list2.length){
							list.push(list2.randomRemove());
						}
						else{
							equipped=true;
							list.push(list1.randomRemove());
						}
					}
					player.chooseButton(true,['幻觉',[list,'vcard']]).ai=function(button){
						var card={suit:trigger.card.suit,number:trigger.card.number,name:button.link[2]};
						return get.effect(trigger.targets[0],card,trigger.player,player);
					};
					'step 1'
					if(result.bool){
						var card=game.createCard({
							suit:trigger.card.suit||lib.suit.randomGet(),
							number:trigger.card.number||Math.ceil(Math.random()*13),
							name:result.links[0][2]}
						);
						event.card=card;
						game.log(player,'将',trigger.card,'变为',card);
						// if(!event.isMine()) game.delayx();
						trigger.card=get.autoViewAs(card);
						trigger.cards=[card];
						game.cardsGotoOrdering(card).relatedEvent=trigger;
					}
					else{
						event.finish();
					}
					'step 2'
					player.$throw(event.card,null,null,true);
					if(player==trigger.player){
						player.line(trigger.targets[0],'green');
					}
					else{
						player.line(trigger.player,'green');
					}
					game.delayx(0.5);
				},
				ai:{
					threaten:0.1
				}
			},
			hshuanling:{
				trigger:{player:'phaseEnd'},
				direct:true,
				filter(event,player){
					return player.storage.hshuanling.length&&player.countCards('he');
				},
				init(player){
					player.storage.hshuanling=[];
				},
				intro:{
					content:'cards'
				},
				content(){
					'step 0'
					var num=Math.min(
						Math.max(1,player.countCards('e')),
						player.storage.hshuanling.length
					);
					var next=player.chooseToDiscard('he',get.prompt2('hshuanling'),[1,num]);
					next.ai=function(card){
						if(get.position(card)=='e') return 7-get.value(card);
						return 8-get.value(card);
					};
					next.logSkill='hshuanling';
					next.delay=false;
					'step 1'
					if(result.bool){
						event.num=result.cards.length;
						player.draw(event.num);
					}
					else{
						event.finish();
					}
					'step 2'
					if(event.num){
						var targets=game.filterPlayer();
						var list=player.storage.hshuanling.slice(0);
						while(list.length){
							var choice=list.randomRemove();
							var card=game.createCard(choice);
							var target;
							while(targets.length){
								target=targets.randomRemove();
								if(lib.filter.targetEnabled2(card,player,target)&&
									get.effect(target,card,player,player)>0){
									break;
								}
								target = null;
							}
							if(target){
								player.storage.hshuanling.remove(choice);
								if(!player.storage.hshuanling.length){
									player.unmarkSkill('hshuanling');
								}
								else{
									player.syncStorage('hshuanling');
									player.updateMarks();
								}
								player.useCard(card,target);
								break;
							}
						}
						event.num--;
						event.redo();
					}
				},
				group:['hshuanling_count'],
				subSkill:{
					// clear:{
					// 	trigger:{player:'phaseAfter'},
					// 	silent:true,
					// 	content(){
					// 		player.storage.hshuanling.length=0;
					// 	}
					// },
					count:{
						trigger:{global:'useCard'},
						silent:true,
						filter(event,player){
							if(get.is.converted(event)) return false;
							if(!event.player.isEnemiesOf(player)) return false;
							if(get.type(event.card)!='trick') return false;
							if(event.targets.length!=1) return false;
							// if(!event.targets[0].isFriendsOf(player)) return false;
							if(get.info(event.card).multitarget) return false;
							if(get.info(event.card).singleCard) return false;
							if(!get.info(event.card).enable) return false;
							return true;
						},
						content(){
							player.storage.hshuanling.add(trigger.card);
							player.markSkill('hshuanling');
						}
					}
				}
			},
			hsxiujian:{
				trigger:{player:'useCardToAfter'},
				forced:true,
				filter(event,player){
					return get.type2(event.card)=='trick'&&event.target.isEnemiesOf(player);
				},
				content(){
					player.useCard({name:'sha'},trigger.target,false);
				}
			},
			hsxingyi:{
				trigger:{global:'useSkillAfter'},
				forced:true,
				filter(event,player){
					if(lib.filter.skillDisabled(event.skill)) return false;
					if(!game.expandSkills(event.player.getStockSkills()).includes(event.skill)) return false;
					return _status.currentPhase==event.player&&event.player.isEnemiesOf(player);
				},
				content(){
					player.addTempSkill(trigger.skill,{player:'phaseAfter'});
				}
			},
			hshuanling_old:{
				trigger:{player:'useCardAfter'},
				forced:true,
				subSkill:{
					basic:{},
					trick:{}
				},
				usable:1,
				filter(event,player){
					if(!event.targets) return false;
					if(event.targets.length>1) return false;
					if(event.targets[0]==player) return false;
					return get.type2(event.card)=='trick';
				},
				content(){
					var list=get.inpile2('trick');
					while(list.length){
						var name=list.randomRemove();
						if(!lib.card[name].multitarget&&
							player.canUse(name,trigger.targets[0])&&
							get.effect(trigger.targets[0],{name:name},player,player)>0){
							player.useCard(game.createCard(name),trigger.targets[0],false);
							break;
						}
					}
				}
			},
			hshuanling_old2:{
				trigger:{player:'useCard'},
				filter(event,player){
					// if(get.is.converted(event)) return false;
					if(!player.countCards('he')) return false;
					// if(!event.targets||!event.targets.includes(player)) return false;
					var info=get.info(event.card);
					if(info.type!='trick'&&info.type!='basic') return false;
					if(info.multitarget) return false;
					if(event.targets.length>1) return true;
					return game.hasPlayer(function(current){
						return !event.targets.includes(current)&&lib.filter.targetEnabled2(event.card,event.player,current);
					});
				},
				direct:true,
				content(){
					'step 0'
					var bool1=(trigger.targets.length>1);
					var bool2=game.hasPlayer(function(current){
						return !trigger.targets.includes(current)&&lib.filter.targetEnabled2(trigger.card,trigger.player,current);
					});
					if(bool1&&bool2){
						player.chooseControlList(true,get.prompt('hshuanling'),[
							'弃置任意张牌 ，并为'+get.translation(trigger.card)+'增加等量的目标',
							'弃置任意张牌 ，并为'+get.translation(trigger.card)+'减少等量的目标'],function(event,player){
							if(_status.event.add) return 0;
							return 1;
						}).set('add',get.effect(player,trigger.card,trigger.player,player)>=0);
					}
					else if(bool2){
						event.type='add';
						event.goto(2);
						event.unchosen=true;
					}
					else{
						event.type='remove';
						event.goto(2);
						event.unchosen=true;
					}
					'step 1'
					if(result.control=='cancel2'){
						event.finish();
					}
					else if(result.index==1){
						event.type='remove';
					}
					else{
						event.type='add';
					}
					'step 2'
					if(event.type=='add'){
						var num=game.countPlayer(function(current){
							return !trigger.targets.includes(current)&&lib.filter.targetEnabled2(trigger.card,trigger.player,current);
						});
						var num2=game.countPlayer(function(current){
							if(!trigger.targets.includes(current)&&lib.filter.targetEnabled2(trigger.card,trigger.player,current)){
								return get.effect(current,trigger.card,player,player)>0;
							}
							return false;
						});
						if(num2>2) num2=2;
						player.chooseCardTarget({
							selectCard:[1,num],
							selectTarget(){
								return ui.selected.cards.length;
							},
							position:'he',
							prompt:event.unchosen?get.prompt('hshuanling'):null,
							prompt2:'弃置任意张牌，并为'+get.translation(trigger.card)+'增加等量的目标',
							filterTarget(card,player,target){
								return !trigger.targets.includes(target)&&lib.filter.targetEnabled2(trigger.card,trigger.player,target);
							},
							ai1(card){
								if(ui.selected.cards.length>=num2) return 0;
								return get.value(trigger.card)-get.value(card)-1;
							},
							ai2(target){
								var trigger=_status.event.getTrigger();
								return get.effect(target,trigger.card,trigger.player,_status.event.player);
							}
						});
					}
					else{
						var num=trigger.targets.length-1;
						var num2=game.countPlayer(function(current){
							if(trigger.targets.includes(current)){
								return get.effect(current,trigger.card,player,player)<0;
							}
							return false;
						});
						if(num2>2) num2=2;
						player.chooseCardTarget({
							selectCard:[1,num],
							selectTarget(){
								return ui.selected.cards.length;
							},
							prompt:event.unchosen?get.prompt('hshuanling'):null,
							prompt2:'弃置任意张牌，并为'+get.translation(trigger.card)+'减少等量的目标',
							filterTarget(card,player,target){
								return trigger.targets.includes(target);
							},
							ai1(card){
								if(!player.needsToDiscard(0,(i,player)=>{
									return !ui.selected.cards.includes(i)&&!player.canIgnoreHandcard(i);
								})) return 0;
								if(ui.selected.cards.length>=num2) return 0;
								return Math.max(5,get.value(trigger.card))-get.value(card)-1;
							},
							ai2(target){
								var trigger=_status.event.getTrigger();
								return -get.effect(target,trigger.card,trigger.player,_status.event.player);
							}
						});
					}
					'step 3'
					if(result.bool){
						if(!event.isMine()) game.delayx();
						event.targets=result.targets.slice(0);
						event.cards=result.cards.slice(0);
					}
					else{
						event.finish();
					}
					'step 4'
					player.logSkill('hshuanling',event.targets);
					player.discard(event.cards).delay=false;
					if(event.type=='add'){
						for(var i=0;i<event.targets.length;i++){
							trigger.targets.push(event.targets[i]);
						}
					}
					else{
						for(var i=0;i<event.targets.length;i++){
							trigger.targets.remove(event.targets[i]);
						}
					}
				},
				ai:{
					expose:0.2
				}
			},
			asyouzhang:{
				trigger:{player:'phaseEnd'},
				frequent:true,
				filter(event,player){
					if(player.countCards('h',{type:'basic'})==0) return true;
					if(player.countCards('h',{type:['trick','delay']})==0) return true;
					if(player.countCards('h',{type:'equip'})==0) return true;
					return false;
				},
				content(){
					'step 0'
					if(player.countCards('h',{type:'basic'})==0){
						var card=get.cardPile(function(card){
							return get.type(card)=='basic';
						});
						if(card){
							player.gain(card,'draw');
						}
						event.basiccard=card;
					}
					'step 1'
					if(event.basiccard){
						if(player.hasUseTarget(event.basiccard)){
							var next=player.chooseToUse();
							next.filterCard=function(card){
								return card==event.basiccard;
							};
							next.prompt='是否使用'+get.translation(event.basiccard)+'？';
						}
					}
					'step 2'
					if(player.countCards('h',{type:['trick','delay']})==0){
						var card=get.cardPile(function(card){
							return get.type(card)=='trick'||get.type(card)=='delay';
						});
						if(card){
							player.gain(card,'draw');
						}
						event.trickcard=card;
					}
					'step 3'
					if(event.trickcard){
						if(player.hasUseTarget(event.trickcard)){
							var next=player.chooseToUse();
							next.filterCard=function(card){
								return card==event.trickcard;
							};
							next.prompt='是否使用'+get.translation(event.trickcard)+'？';
						}
					}
					'step 4'
					if(player.countCards('h',{type:'equip'})==0){
						var card=get.cardPile(function(card){
							return get.type(card)=='equip';
						});
						if(card){
							player.gain(card,'draw');
						}
						event.equipcard=card;
					}
					'step 5'
					if(event.equipcard){
						if(player.hasUseTarget(event.equipcard)){
							var next=player.chooseToUse();
							next.filterCard=function(card){
								return card==event.equipcard;
							};
							next.prompt='是否使用'+get.translation(event.equipcard)+'？';
						}
					}
				},
				ai:{
					threaten:1.7
				}
			},
			ylyuchu:{
				trigger:{player:'recoverAfter'},
				forced:true,
				filter(event,player){
					if(player.hasSkill('subplayer')) return false;
					return player.storage.ylyuchu.length<3;
				},
				init(player){
					if(!player.storage.ylyuchu) player.storage.ylyuchu=[];
				},
				ai:{
					threaten:0.7
				},
				// onremove(player){
				// 	delete player.storage.ylyuchu;
				// 	delete player.storage.ylyuchu2;
				// 	delete player.storage.ylyuchu3;
				// },
				group:['ylyuchu_swap','ylyuchu_phase'],
				subSkill:{
					chosen:{},
					swap:{
						trigger:{player:'phaseEnd'},
						silent:true,
						filter(event,player){
							return player.storage.ylyuchu.length;
						},
						content(){
							var list=game.filterPlayer();
							list.remove(player);
							player.storage.ylyuchu2=list.randomGets(player.storage.ylyuchu.length);
							player.storage.ylyuchu3=player.storage.ylyuchu.slice(0).randomSort();
						}
					},
					phase:{
						trigger:{global:'phaseBefore'},
						forced:true,
						popup:false,
						filter(event,player){
							if(player.hasSkill('subplayer')) return false;
							if(player.storage.ylyuchu2&&player.storage.ylyuchu3){
								var idx=player.storage.ylyuchu2.indexOf(event.player);
								var target=player.storage.ylyuchu3[idx];
								if(target&&player.storage.ylyuchu.includes(target)){
									return true;
								}
							}
							return false;
						},
						content(){
							if(player.storage.ylyuchu2&&player.storage.ylyuchu3){
								var idx=player.storage.ylyuchu2.indexOf(trigger.player);
								var target=player.storage.ylyuchu3[idx];
								if(target&&player.storage.ylyuchu.includes(target)){
									player.callSubPlayer(target);
									player.storage.ylyuchu2[idx]=null;
								}
							}
						}
					},
					exit:{
						trigger:{player:['phaseAfter']},
						forced:true,
						popup:false,
						priority:-60,
						content(){
							player.exitSubPlayer();
						}
					},
					draw:{
						trigger:{player:'phaseDrawBegin'},
						silent:true,
						filter(event){
							return event.num>0;
						},
						content(){
							trigger.num--;
						}
					},
					enter:{
						trigger:{global:'phaseAfter'},
						forced:true,
						popup:false,
						priority:-60,
						filter(event,player){
							return event.player!=player;
						},
						content(){
							player.insertPhase(null,true);
						}
					}
				},
				content(){
					'step 0'
					event.num=trigger.num;
					'step 1'
					if(event.num&&player.storage.ylyuchu.length<3){
						var skill=player.addSubPlayer({
							name:'hs_yelinchulong',
							skills:['ylyuchu_draw','ylyuchu_exit','ylyuchu_enter'],
							hp:2,
							maxHp:2,
							hs:get.cards(2),
							skill:skill,
							// intro:'下个敌方回合开始前，随机切换至此随从',
							intro2:'当前回合结束后进行一个额外回合并切换回本体',
							onremove(player){
								player.storage.ylyuchu.remove(skill);
								delete lib.skill[skill];
							}
						});
						player.storage.ylyuchu.push(skill);
						event.num--;
						event.redo();
					}
				}
			},
			nsaiqi:{
				trigger:{player:'useCard'},
				forced:true,
				init(player){
					player.storage.nsaiqi=[];
				},
				intro:{
					content:'cards'
				},
				filter(event,player){
					if(ui.cardPile.firstChild&&ui.cardPile.firstChild.vanishtag.includes('nsaiqi')){
						return false;
					}
					return true;
				},
				onremove:'lose',
				content(){
					var cards=get.cards(3);
					for(var i=0;i<cards.length;i++){
						cards[i].vanishtag.add('nsaiqi');
					}
					player.storage.nsaiqi.addArray(cards);
					player.syncStorage('nsaiqi');
					player.markSkill('nsaiqi');
				},
				mod:{
					maxHandcard(player,num){
						return num+1;
					}
				}
			},
			nsbeiming:{
				trigger:{player:'nsaiqiAfter'},
				forced:true,
				filter(event,player){
					return player.storage.nsaiqi.length>=9;
				},
				content(){
					'step 0'
					player.draw();
					'step 1'
					player.chooseCardButton(player.storage.nsaiqi,true,'将顺序将牌置于牌堆顶（先选择的在上）',player.storage.nsaiqi.length);
					'step 2'
					var list=result.links.slice(0);
					while(list.length){
						ui.cardPile.insertBefore(list.pop(),ui.cardPile.firstChild);
					}
					player.storage.nsaiqi.length=0;
					player.unmarkSkill('nsaiqi');
				}
			},
			hsnitai:{
				trigger:{player:'phaseUseBegin'},
				forced:true,
				video(player,data){
					var skills=data[0];
					var name=data[1];
					lib.skill.hsnitai.process(skills,name);
				},
				onremove(player){
					player.removeSkill('hsnitai_card');
				},
				process(skills,name){
					var cardname='hsnitai_'+name;
					lib.translate[cardname]=lib.translate[name];
					lib.translate[cardname+'_info']='出牌阶段对自己使用，获得'+get.translation(name)+'的一个技能（替换前一个以此法获得的技能，效果持续2回合）';
					lib.translate[cardname+'_append']='';
					for(var i=0;i<skills.length;i++){
						lib.translate[cardname+'_append']+='<div class="skill">【'+lib.translate[skills[i]]+'】</div><div>'+
						get.skillInfoTranslation(skills[i])+'</div>';
						if(i<skills.length){
							lib.translate[cardname+'_append']+='<br>'
						}
					}
					lib.card[cardname]=lib.card[cardname]||{
						enable:true,
						type:'character',
						image:'character:'+name,
						fullimage:true,
						vanish:true,
						skills:skills,
						derivation:'hs_barnes',
						filterTarget(card,player,target){
							return player==target;
						},
						selectTarget:-1,
						content(){
							'step 0'
							var list=lib.card[card.name].skills;
							for(var i=0;i<list.length;i++){
								if(target.hasSkill(list[i])){
									list.splice(i--,1);
								}
							}
							if(!list.length){
								event.finish();
								return;
							}
							event.skillai=function(){
								return get.max(list,get.skillRank,'item');
							};
							if(list.length==1){
								event._result=list[0];
							}
							else if(event.isMine()){
								var dialog=ui.create.dialog('forcebutton');
								dialog.add('选择获得一项技能');
								var clickItem=function(){
									_status.event._result=this.link;
									dialog.close();
									game.resume();
								};
								for(var i=0;i<list.length;i++){
									if(lib.translate[list[i]+'_info']){
										var translation=get.translation(list[i]);
										if(translation[0]=='新'&&translation.length==3){
											translation=translation.slice(1,3);
										}
										else{
											translation=translation.slice(0,2);
										}
										var item=dialog.add('<div class="popup pointerdiv" style="width:80%;display:inline-block"><div class="skill">【'+
										translation+'】</div><div>'+lib.translate[list[i]+'_info']+'</div></div>');
										item.firstChild.addEventListener('click',clickItem);
										item.firstChild.link=list[i];
									}
								}
								dialog.add(ui.create.div('.placeholder'));
								event.switchToAuto=function(){
									event._result=event.skillai();
									dialog.close();
									game.resume();
								};
								_status.imchoosing=true;
								game.pause();
							}
							else{
								event._result=event.skillai();
							}
							'step 1'
							var skill=result;
							if(!target.hasSkill(skill)){
								player.popup(skill);
								target.$gain2(card);
								target.removeSkill('hsnitai_card');
								target.storage.hsnitai_card=card;
								target.storage.hsnitai_card_count=1;
								target.storage.hsnitai_card_skill=skill;
								player.syncStorage('hsnitai_card');
								player.syncStorage('hsnitai_card_skill');
								target.addAdditionalSkill('hsnitai_card',skill);
								target.addSkill('hsnitai_card');
								game.log(target,'获得技能','【'+get.translation(skill)+'】');
							}
						},
						ai:{
							order(){
								if(_status.event.player.hasSkill('hsnitai_card')) return 1;
								return 9;
							},
							result:{
								target(player,target){
									if(!player.hasSkill('hsnitai_card')||player.needsToDiscard()) return 1;
									return 0;
								}
							}
						}
					};
				},
				content(){
					var current=game.expandSkills(player.getSkills());
					var list=get.gainableSkills(function(info,skill,name){
						if(current.includes(skill)) return false;
						return lib.characterPack.hearth&&lib.characterPack.hearth[name];
					});
					if(!list.length){
						return;
					}
					var skill=list.randomGet();
					var source=[];
					for(var i in lib.characterPack.hearth){
						if(lib.characterPack.hearth[i][3].includes(skill)){
							source.push(i);
						}
					}
					if(!source.length){
						return;
					}
					var name=source.randomGet();
					var skills=[skill];
					var nameskills=lib.characterPack.hearth[name][3]
					for(var i=0;i<nameskills.length;i++){
						if(list.includes(nameskills[i])){
							skills.add(nameskills[i]);
						}
					}
					game.addVideo('skill',player,['hsnitai',[skills,name]]);
					lib.skill.hsnitai.process(skills,name);
					player.gain(game.createCard('hsnitai_'+name),'gain2');
				},
				subSkill:{
					card:{
						mark:'card',
						onremove:['hsnitai_card','hsnitai_card_count','hsnitai_card_skill'],
						intro:{
							content(storage,player){
								var skill=player.storage.hsnitai_card_skill;
								// var skill=storage.name.slice(8);
								return '<div class="skill">【'+lib.translate[skill]+'】</div><div>'+
								get.skillInfoTranslation(skill)+'</div>';
							}
						},
						trigger:{player:'phaseUseBegin'},
						priority:-10,
						silent:true,
						content(){
							if(player.storage.hsnitai_card_count>0){
								player.storage.hsnitai_card_count--;
							}
							else{
								player.removeSkill('hsnitai_card');
							}
						}
					}
				}
			},
			hspuzhao:{
				enable:'phaseUse',
				usable:1,
				filterCard:{suit:'heart'},
				position:'he',
				filter(event,player){
					return player.countCards('he',{suit:'heart'})>0;
				},
				check(card){
					return 7-get.value(card);
				},
				content(){
					var targets=player.getFriends();
					if(targets.length){
						targets.push(player);
						if(targets.length>3){
							targets=targets.randomGets(3);
						}
						targets.sortBySeat();
						player.line(targets,'green');
						for(var i=0;i<targets.length;i++){
							targets[i].addExpose(0.2);
						}
						game.asyncDraw(targets);
					}
					else{
						player.draw(2);
					}
				},
				ai:{
					order:10,
					expose:0.3,
					result:{
						player:1
					}
				}
			},
			hsyanxin:{
				trigger:{player:'drawBegin'},
				priority:-5,
				filter(event,player){
					if(game.fixedPile) return false;
					if(event.num<=0) return false;
					if(ui.cardPile.childNodes.length==0) return false;
					if(get.color(ui.cardPile.firstChild)=='red') return false;
					return true;
				},
				forced:true,
				popup:false,
				content(){
					var card=ui.cardPile.firstChild;
					if(lib.inpile.includes(card.name)){
						for(var i=1;i<ui.cardPile.childElementCount;i++){
							var card2=ui.cardPile.childNodes[i];
							if(get.color(card2)=='red'){
								ui.cardPile.insertBefore(card2,card);
								break;
							}
						}
					}
					else{
						card.init([['heart','diamond'].randomGet(),card.number,card.name,card.nature]);
					}
				}
			},
			hstianqi:{
				enable:'phaseUse',
				usable:1,
				filter(event,player){
					return player.countCards('he')>0;
				},
				position:'he',
				init(player){
					player.storage.hstianqi=[];
				},
				onremove:true,
				filterCard(card,player){
					if(get.position(card)=='h'){
						if(player.getEquip(1)&&player.getEquip(2)&&
							player.getEquip(3)&&player.getEquip(4)){
							return false;
						}
						return true;
					}
					else{
						return true;
					}
				},
				check(card){
					var player=_status.event.player;
					if(get.position(card)=='e'){
						if(card.name.indexOf('hstianqi_')==0){
							for(var i=0;i<player.storage.hstianqi.length;i++){
								if(player.storage.hstianqi[i].name==card.name) return 0;
							}
							return 20-get.value(card);
						}
						else{
							return (9-get.value(card))/5;
						}
					}
					else{
						if(get.type(card)=='equip'){
							return 9-get.value(card);
						}
						return 7-get.value(card);
					}
				},
				discard:false,
				lose:false,
				delay:0,
				intro:{
					content:'cards'
				},
				content(){
					'step 0'
					event.position=get.position(cards[0]);
					player.discard(cards);
					if(event.position=='e'){
						var name=cards[0].name;
						if(name.indexOf('hstianqi_')!=0) return;
						for(var i=0;i<player.storage.hstianqi.length;i++){
							if(player.storage.hstianqi[i].name==name){
								return;
							}
						}
						player.storage.hstianqi.add(cards[0]);
						player.markSkill('hstianqi');
					}
					'step 1'
					if(event.position=='h'){
						var list=[];
						if(!player.getEquip(1)){
							list.push({name:'hstianqi_dalian',suit:'spade',number:1});
						}
						if(!player.getEquip(2)){
							list.push({name:'hstianqi_shali',suit:'heart',number:1});
						}
						if(!player.getEquip(3)){
							list.push({name:'hstianqi_suolasi',suit:'diamond',number:1});
						}
						if(!player.getEquip(4)){
							list.push({name:'hstianqi_nazigelin',suit:'club',number:1});
						}
						if(list.length){
							player.equip(game.createCard(list.randomGet()),true);
						}
					}
					else{
						player.draw(2);
						event.finish();
					}
					'step 2'
					if(!event.isMine()){
						game.delay(0.5);
					}
				},
				group:['hstianqi_win'],
				subSkill:{
					win:{
						trigger:{player:'phaseBegin'},
						priority:30,
						forced:true,
						skillAnimation:true,
						animationColor:'legend',
						filter(event,player){
							return player.storage.hstianqi.length==4;
						},
						content(){
							'step 0'
							game.delay();
							'step 1'
							if(game.showIdentity){
								game.showIdentity();
							}
							if(player.isUnderControl(true)||player.getFriends().includes(game.me)){
								game.over(true);
							}
							else{
								game.over(false);
							}
						}
					}
				},
				ai:{
					threaten(player,target){
						if(target.storage.hstianqi.length==4) return 20;
						if(target.storage.hstianqi.length==3) return 2;
						return 1;
					},
					order:9,
					result:{
						player:1
					}
				}
			},
			hstianqi_dalian:{
				trigger:{source:'damageEnd'},
				forced:true,
				filter(event,player){
					return player.isDamaged();
				},
				content(){
					player.recover(trigger.num);
				}
			},
			hstianqi_shali:{
				trigger:{player:'recoverEnd'},
				forced:true,
				filter(event,player){
					return event.num>0;
				},
				content(){
					player.changeHujia(trigger.num);
				}
			},
			ysjqisha:{
				trigger:{source:'damageEnd',player:'damageEnd'},
				forced:true,
				filter(event,player){
					if(event._notrigger.includes(event.player)) return false;
					return (event.source!=player&&event.source.isIn())||(event.player!=player&&event.player.isIn());
				},
				content(){
					var target=trigger.source;
					if(target==player){
						target=trigger.player;
					}
					var list=['ju','kuang','nu','yi','wang','hen','ao'];
					for(var i=0;i<list.length;i++){
						list[i]='ysjqisha_'+list[i];
						if(target.hasSkillTag(list[i])){
							list.splice(i--,1);
						}
					}
					if(list.length){
						target.addTempSkill(list.randomGet(),{player:'phaseAfter'});
					}
				},
				ai:{
					threaten:0.8,
					maixie_defend:true,
				},
				subSkill:{
					ju:{
						mark:true,
						intro:{
							content:'锁定技，每当你使用一张牌，需弃置一张牌'
						},
						trigger:{player:'useCard'},
						forced:true,
						filter(event,player){
							return player.countCards('he')>0;
						},
						content(){
							game.delay(0.5);
							player.chooseToDiscard(true,'he');
						}
					},
					kuang:{
						mark:true,
						intro:{
							content:'锁定技，每当你使用一张牌指定惟一目标，有50%的机率指定错误的目标'
						},
						trigger:{player:'useCard'},
						forced:true,
						filter(event,player){
							return event.getRand()<0.5&&event.targets&&event.targets.length==1&&game.hasPlayer(function(current){
								return current!=event.targets[0]&&lib.filter.targetEnabled2(event.card,player,current);
							});
						},
						content(){
							'step 0'
							game.delay();
							'step 1'
							var list=game.filterPlayer(function(current){
								return current!=trigger.targets[0]&&lib.filter.targetEnabled2(trigger.card,player,current);
							});
							if(list.length){
								var target=list.randomGet();
								trigger.targets[0]=target;
								player.line(target,'green');
							}
						}
					},
					nu:{
						mark:true,
						intro:{
							content:'锁定技，你使用的卡牌造成的伤害+1；每当你使用一张牌，有65%的机率失效'
						},
						forced:true,
						trigger:{source:'damageBegin',player:'useCardToBefore'},
						filter(event,player){
							if(event.name=='damage') return event.notLink()&&(event.card?true:false);
							var info=get.info(event.card);
							if(info.multitarget&&event.targets&&event.targets.includes(player)) return false;
							return event.getRand()<0.65;
						},
						content(){
							if(trigger.name=='damage'){
								trigger.num++;
							}
							else{
								trigger.cancel();
							}
						}
					},
					yi:{
						mark:true,
						intro:{
							content:'锁定技，你不能成为非敌方角色的卡牌目标'
						},
						mod:{
							targetEnabled(card,player,target){
								if(!player.getEnemies().includes(target)) return false;
							}
						}
					},
					wang:{
						mark:true,
						intro:{
							content:'锁定技，你的摸牌数始终-1'
						},
						priority:5,
						trigger:{player:'drawBegin'},
						forced:true,
						content(){
							trigger.num--;
						}
					},
					hen:{
						mark:true,
						intro:{
							content:'锁定技，每当一名敌方角色回复1点体力，你失去1点体力'
						},
						trigger:{global:'recoverAfter'},
						forced:true,
						filter(event,player){
							return player.getEnemies().includes(event.player);
						},
						content(){
							player.loseHp();
						}
					},
					ao:{
						mark:true,
						intro:{
							content:'锁定技，你的手牌上限-2'
						},
						mod:{
							maxHandcard(player,num){
								return num-2;
							}
						}
					},
				}
			},
			yindan:{
				enable:'phaseUse',
				filterCard:{suit:'spade'},
				check(card){
					return 8-get.value(card);
				},
				usable:1,
				filter(event,player){
					return player.countCards('he',{suit:'spade'})>0;
				},
				position:'he',
				content(){
					'step 0'
					player.loseHp();
					'step 1'
					var cards=[];
					for(var i=0;i<2;i++){
						cards.push(game.createCard('hsjixie_zhadan'));
					}
					player.gain(cards,'gain2');
				},
				ai:{
					order:7,
					result:{
						player(player,target){
							if(player.hp>=3) return 1;
							if(player.hp==2&&game.hasPlayer(function(current){
								return get.damageEffect(current,player,player,'fire')>0&&current.hp==1;
							})){
								return 1;
							}
							return 0;
						}
					}
				}
			},
			hllingxi:{
				enable:'phaseUse',
				filter(event,player){
					return game.hasPlayer(function(target){
						return lib.skill.hllingxi.filterTarget(null,player,target);
					});
				},
				filterTarget(card,player,target){
					if(target.hasSkill('hllingxi_used')) return false;
					return target!=player&&target.isDamaged()&&target.countCards('he')>=2;
				},
				content(){
					'step 0'
					target.chooseToDiscard('he',2,true);
					'step 1'
					target.recover();
					target.addTempSkill('hllingxi_used');
				},
				group:'hllingxi_end',
				subSkill:{
					used:{},
					end:{
						trigger:{player:'phaseEnd'},
						frequent:true,
						filter(event,player){
							return player.isDamaged();
						},
						content(){
							player.recover();
						}
					}
				},
				ai:{
					order:6,
					result:{
						target(player,target){
							var nc=target.countCards('he');
							if(target.hasSkillTag('maixie_hp')){
								if(nc>=3) return 1;
								if(target.hp==1) return 1;
								return 0;
							}
							if(nc>=4){
								if(target.hp<=2) return 1;
								return 0;
							}
							else if(nc==3){
								if(target.hp==1) return 1;
								if(target.hp>=4) return -1;
								return 0;
							}
							else{
								if(target.hp==1) return 0;
								return -1;
							}
						}
					}
				}
			},
			zhaochao:{
				trigger:{player:'phaseEnd'},
				forced:true,
				filter(event,player){
					return player.getEnemies().length>0;
				},
				content(){
					'step 0'
					event.targets=player.getEnemies();
					player.addSkill('zhaochao2');
					player.useCard({name:'sha'},event.targets.randomRemove());
					'step 1'
					player.removeSkill('zhaochao2');
					if(player.storage.zhaochao2&&event.targets.length){
						player.useCard({name:'sha'},event.targets.randomRemove());
						delete player.storage.zhaochao2;
					}
				},
				ai:{
					threaten:1.7
				}
			},
			zhaochao2:{
				trigger:{player:'shaMiss'},
				silent:true,
				filter(event){
					return event.getParent(2).name=='zhaochao';
				},
				content(){
					player.storage.zhaochao2=true;
				}
			},
			xiyong:{
				trigger:{player:'phaseEnd'},
				frequent:true,
				content(){
					'step 0'
					player.draw();
					'step 1'
					if(Array.isArray(result)&&result.length){
						var gained=result[0];
						if(lib.filter.cardEnabled(gained,target)){
							var next=player.chooseToUse();
							next.filterCard=function(card){
								return card==gained;
							};
							next.prompt='是否使用'+get.translation(gained)+'？';
						}
						else{
							event.finish();
						}
					}
					else{
						event.finish();
					}
					'step 2'
					if(result.bool){
						player.draw();
					}
				},
				ai:{
					threaten:1.6
				}
			},
			srjici:{
				trigger:{source:'damageEnd'},
				forced:true,
				content(){
					player.draw();
					if(trigger.player&&trigger.player.isIn()&&!trigger._notrigger.includes(trigger.player)){
						trigger.player.randomDiscard();
					}
				},
				ai:{
					threaten:1.4
				}
			},
			yinzong:{
				trigger:{player:'loseEnd'},
				forced:true,
				filter(event,player){
					for(var i=0;i<event.cards.length;i++){
						if(event.cards[i].original=='e') return true;
					}
					return false;
				},
				content(){
					// player.tempHide();
					player.gain(game.createCard('shan'),'gain2');
				}
			},
			tansuo:{
				enable:'phaseUse',
				usable:1,
				filterCard:true,
				position:'he',
				check(card){
					return 8-get.value(card)
				},
				content(){
					if(!lib.characterPack.hearth){
						player.draw();
						return;
					}
					var list=[];
					for(var i=0;i<lib.cardPack.mode_derivation.length;i++){
						var name=lib.cardPack.mode_derivation[i];
						var info=lib.card[name];
						if(info.gainable==false||info.destroy) continue;
						if(lib.characterPack.hearth[info.derivation]){
							list.push(name);
						}
					}
					if(!list.length){
						player.draw();
					}
					else{
						player.discoverCard(list);
						// player.gain(game.createCard(list.randomGet()),'draw');
					}
				},
				ai:{
					threaten:1.6,
					order:8,
					result:{
						player:1
					},
				}
			},
			lieqi:{
				trigger:{player:['phaseBegin','phaseEnd']},
				filter(event,player){
					return game.hasPlayer(function(current){
						return !current.isUnderControl(true,player)&&current!=player.storage.lieqi&&current.countCards('h');
					});
				},
				direct:true,
				content(){
					'step 0'
					player.chooseTarget(get.prompt('lieqi'),function(card,player,target){
						return !target.isUnderControl(true,player)&&target!=player.storage.lieqi&&target.countCards('h');
					}).ai=function(){
						return 1;
					}
					'step 1'
					if(result.bool){
						var target=result.targets[0];
						player.logSkill('lieqi',target);
						if(event.triggername=='phaseBegin'){
							player.storage.lieqi=target;
						}
						var hs=target.getCards('h').randomSort();
						if(hs.length){
							var list2=[];
							for(var i=0;i<hs.length;i++){
								if(list2.includes(hs[i].name)){
									hs.splice(i--,1);
								}
								else{
									list2.push(hs[i].name);
								}
							}
							var card=hs.randomGet();
							var list=[];
							for(var i=0;i<lib.inpile.length;i++){
								if(!list2.includes(lib.inpile[i])&&
									(get.type(lib.inpile[i])!='equip'||Math.random()<0.5)){
									list.push(lib.inpile[i]);
								}
							}
							event.card=card;
							player.chooseCardButton(true,'猜测哪张牌为'+get.translation(target)+'的手牌',
							[card,game.createCard(list.randomRemove()),game.createCard(list.randomRemove())].randomSort()).ai=function(button){
								if(get.value(button.link)<0) return -10;
								if(_status.event.getRand()<0.7){
									return button.link==card?1:-1;
								}
								else{
									return button.link==card?-1:1;
								}
							};
						}
						else{
							event.finish();
						}
					}
					else{
						event.finish();
					}
					if(event.triggername=='phaseEnd'){
						delete player.storage.lieqi;
					}
					'step 2'
					if(result.bool&&result.links){
						if(result.links[0]==event.card){
							player.gain(game.createCard(event.card),'draw');
						}
						else{
							player.viewCards('正确答案',[event.card]);
						}
					}
				},
				ai:{
					threaten:1.5
				}
			},
			azaowu:{
				enable:'phaseUse',
				usable:1,
				filter(event,player){
					if(event.filterCard({name:'sha'},player,event)||
						event.filterCard({name:'jiu'},player,event)||
						event.filterCard({name:'tao'},player,event)){
						return player.hasCard(function(card){
							return get.type(card)=='basic';
						});
					}
					return false;
				},
				chooseButton:{
					dialog(event,player){
						var list=[];
						if(event.filterCard({name:'sha'},player,event)){
							list.push(['基本','','sha']);
							list.push(['基本','','sha','fire']);
							list.push(['基本','','sha','thunder']);
						}
						for(var i=0;i<lib.inpile.length;i++){
							if(lib.inpile[i]!='sha'&&
								lib.card[lib.inpile[i]].type=='basic'&&
								event.filterCard({name:lib.inpile[i]},player,event)){
								list.push(['基本','',lib.inpile[i]]);
							}
						}
						return ui.create.dialog('造物',[list,'vcard'],'hidden');
					},
					check(button){
						var player=_status.event.player;
						var card={name:button.link[2],nature:button.link[3]};
						if(game.hasPlayer(function(current){
							return player.canUse(card,current)&&get.effect(current,card,player,player)>0;
						})){
							switch(button.link[2]){
								case 'tao':return 5;
								case 'xuejibingbao': return 4;
								case 'jiu':return 3.01;
								case 'sha':
									if(button.link[3]=='fire') return 2.95;
									else if(button.link[3]=='thunder') return 2.92;
									else return 2.9;
								default:return 2+_status.event.getRand()*2;
							}
						}
						return 0;
					},
					backup(links,player){
						return {
							filterCard(card){
								return get.type(card)=='basic';
							},
							viewAs:{name:links[0][2],nature:links[0][3]},
							popname:true,
							ai1(card){
								return 6-get.value(card);
							}
						}
					},
					prompt(links,player){
						return '将一张基本牌当作'+get.translation(links[0][3]||'')+get.translation(links[0][2])+'使用';
					}
				},
				ai:{
					order(){
						var player=_status.event.player;
						var event=_status.event;
						if(event.filterCard({name:'jiu'},player,event)&&get.effect(player,{name:'jiu'})>0){
							return 3.1;
						}
						return 2.9;
					},
					result:{
						player:1
					}
				}
			},
			shouwang:{
				enable:'chooseToUse',
				filter(event,player){
					return event.type=='dying'&&event.dying&&!event.dying.hasSkill('shouwang2');
				},
				filterTarget(card,player,target){
					return target==_status.event.dying;
				},
				selectTarget:-1,
				content(){
					target.recover();
					target.changeHujia();
					target.addSkill('shouwang2')
				},
				ai:{
					order:6,
					skillTagFilter(player){
						if(!_status.event.dying||_status.event.dying.hasSkill('shouwang2')) return false;
					},
					save:true,
					result:{
						target:3
					},
					threaten:1.6
				},
			},
			shouwang2:{
				charlotte: true,
				mark:true,
				intro:{
					content:'已发动'
				}
			},
			qingtian:{
				trigger:{player:'damageBegin'},
				forced:true,
				filter(event,player){
					return player.isMaxHp(true);
				},
				check(){
					return false;
				},
				content(){
					trigger.num++;
				}
			},
			qingtian_old:{
				trigger:{player:'recoverBefore'},
				forced:true,
				filter(event,player){
					return player.hp>0&&event.num>0;
				},
				content(){
					trigger.cancel();
					player.changeHujia(trigger.num);
				},
				ai:{
					neg:true
				}
			},
			qianfu:{
				trigger:{player:'dieBefore'},
				forced:true,
				filter(event,player){
					return !player.hasSkill('qianfu2')&&player.maxHp>0;
				},
				unique:true,
				content(){
					trigger.cancel();
					player.addSkill('qianfu2');
					player.hp=1;
					player.update();
					player.discard(player.getCards('he'));
					player.setAvatar('hs_selajin','hs_selajin2');
				},
				ai:{
					threaten:0.8
				}
			},
			qianfu2:{
				mark:true,
				intro:{
					content:'你防止非火焰伤害，不能使用或打出卡牌，并始终跳过你的回合'
				},
				mod:{
					cardEnabled(card,player){
						return false;
					},
					cardUsable(card,player){
						return false;
					},
					cardRespondable(card,player){
						return false;
					},
					cardSavable(card,player){
						return false;
					},
				},
				group:['qianfu2_damage','qianfu2_phase','qianfu2_revive'],
				subSkill:{
					damage:{
						trigger:{player:'damageBefore'},
						filter(event){
							if(event.nature!='fire') return true;
							return false;
						},
						mark:true,
						forced:true,
						content(){
							trigger.cancel();
						},
						ai:{
							nothunder:true,
							nodamage:true,
							effect:{
								target(card,player,target,current){
									if(get.tag(card,'damage')&&!get.tag(card,'fireDamage')) return [0,0];
								}
							},
						},
					},
					phase:{
						trigger:{player:'phaseBefore'},
						forced:true,
						popup:false,
						content(){
							trigger.cancel();
						}
					},
					revive:{
						trigger:{player:['changeHp','loseMaxHpAfter']},
						forced:true,
						filter(event,player){
							return player.hp>=3||player.isHealthy();
						},
						content(){
							player.removeSkill('qianfu2');
							player.draw(3);
							player.setAvatar('hs_selajin','hs_selajin');
						}
					}
				}
			},
			shimo:{
				trigger:{global:'damageAfter'},
				forced:true,
				filter(event,player){
					return event.player!=player&&get.distance(player,event.player)<=1;
				},
				content(){
					if(player.isDamaged()){
						player.recover();
					}
					else{
						player.draw();
					}
				}
			},
			lieyang:{
				trigger:{player:'useCard'},
				forced:true,
				usable:3,
				filter(event,player){
					return _status.currentPhase==player&&get.type(event.card,'trick')=='trick';
				},
				content(){
					var list=get.inpile('trick','trick');
					player.gain(game.createCard(list.randomGet()),'draw');
					if(player.storage.counttrigger&&player.storage.counttrigger.lieyang>=3){
						player.addTempSkill('lieyang2');
					}
				},
				ai:{
					threaten:1.8
				}
			},
			lieyang2:{
				mod:{
					cardEnabled(card){if(get.type(card,'trick')=='trick') return false}
				}
			},
			zhuilie:{
				trigger:{player:'phaseBegin'},
				direct:true,
				filter(event,player){
					return player.countCards('he')>0;
				},
				content(){
					'step 0'
					player.chooseToDiscard('he',get.prompt('zhuilie')).set('ai',function(card){
						if(player.hp>=4||(player.hasSha()&&player.hasShan())){
							return 6-get.value(card);
						}
						if(player.hasSha()||player.hasShan()){
							return 3-get.value(card);
						}
						return 0;
					}).logSkill='zhuilie';
					'step 1'
					if(result.bool){
						var list=[];
						var list2=[];
						for(var i=0;i<6&&i<ui.cardPile.childElementCount;i++){
							list.push(ui.cardPile.childNodes[i]);
						}
						for(var i=0;i<list.length;i++){
							if(get.type(list[i])=='basic'){
								list[i].discard();
								list2.push(list[i]);
							}
						}
						player.showCards(get.translation(player)+'将'+get.cnNumber(list2.length)+'张牌移入弃牌堆',list2);
						if(list2.length>3){
							player.draw();
						}
					}
				}
			},
			szbianshen:{
				trigger:{player:'phaseBefore'},
				unique:true,
				skillAnimation:true,
				forceunique:true,
				filter(){
					return game.roundNumber>=3;
				},
				check(event,player){
					return player.hp<=2;
				},
				content(){
					'step 0'
					var list=get.gainableCharacters(function(info){
						return info[2]>=5;
					});
					var players=game.players.concat(game.dead);
					for(var i=0;i<players.length;i++){
						list.remove(players[i].name);
						list.remove(players[i].name1);
						list.remove(players[i].name2);
					}
					var dialog=ui.create.dialog('将武将牌替换为一名角色','hidden');
					dialog.add([list.randomGets(5),'character']);
					player.chooseButton(dialog,true).ai=function(button){
						return get.rank(button.link,true);
					};
					player.awakenSkill('szbianshen');
					'step 1'
					player.reinit('hs_shizugui',result.links[0]);
					player.hp=player.maxHp;
					player.update();
				}
			},
			kekao:{
				trigger:{player:'phaseEnd'},
				direct:true,
				content(){
					'step 0'
					var list=[];
					for(var i in lib.card){
						if(game.bannedcards&&game.bannedcards.includes(i)) continue;
						if(lib.card[i].type=='delay'){
							list.push(['锦囊','',i]);
						}
					}
					if(list.length==0){
						event.finish();
						return;
					}
					var dialog=ui.create.dialog(get.prompt('kekao'),[list.randomGets(3),'vcard'],'hidden');
					player.chooseButton(dialog).ai=function(button){
						var name=button.link[2]
						var num=Math.random()*get.value({name:name});
						if(lib.card[name].selectTarget==-1){
							return num/10;
						}
						return num;
					};
					'step 1'
					if(result.buttons){
						player.logSkill('kekao');
						player.gain(game.createCard(result.buttons[0].link[2]),'draw');
					}
				},
				ai:{
					threaten:1.6
				}
			},
			jinhua:{
				trigger:{target:'useCardToBegin'},
				forced:true,
				filter(event,player){
					return player==event.player&&get.type(event.card,'trick')=='trick'&&event.card.isCard;
				},
				content(){
					'step 0'
					var list=get.gainableSkills();
					list.remove(player.getSkills());
					list=list.randomGets(3);
					event.skillai=function(){
						return get.max(list,get.skillRank,'item');
					};
					if(event.isMine()){
						var dialog=ui.create.dialog('forcebutton');
						dialog.add('选择获得一项技能');
						var clickItem=function(){
							_status.event._result=this.link;
							dialog.close();
							game.resume();
						};
						for(var i=0;i<list.length;i++){
							if(lib.translate[list[i]+'_info']){
								var translation=get.translation(list[i]);
								if(translation[0]=='新'&&translation.length==3){
									translation=translation.slice(1,3);
								}
								else{
									translation=translation.slice(0,2);
								}
								var item=dialog.add('<div class="popup pointerdiv" style="width:80%;display:inline-block"><div class="skill">【'+
								translation+'】</div><div>'+lib.translate[list[i]+'_info']+'</div></div>');
								item.firstChild.addEventListener('click',clickItem);
								item.firstChild.link=list[i];
							}
						}
						dialog.add(ui.create.div('.placeholder'));
						event.switchToAuto=function(){
							event._result=event.skillai();
							dialog.close();
							game.resume();
						};
						_status.imchoosing=true;
						game.pause();
					}
					else{
						event._result=event.skillai();
					}
					'step 1'
					_status.imchoosing=false;
					var link=result;
					player.addSkill(link,true);
					player.popup(link);
					game.log(player,'获得了技能','【'+get.translation(link)+'】');
					game.delay();
				},
				ai:{
					effect:{
						target(card,player,target){
							if(get.type(card,'trick')=='trick'&&player==target) return [1,1];
						}
					}
				}
			},
			kqizhou:{
				trigger:{player:'phaseBegin'},
				direct:true,
				filter(event,player){
					return player.storage.kqizhou;
				},
				content(){
					'step 0'
					delete player.storage.kqizhou;
					var list=[['','','hsqizhou_feng'],
						['','','hsqizhou_shui'],
						['','','hsqizhou_huo'],
						['','','hsqizhou_tu']];
					var dialog=ui.create.dialog(get.prompt('kqizhou'),[list,'vcard'],'hidden');
					var shui=(player.hp<=1&&player.maxHp>=3);
					var tu=game.hasPlayer(function(current){
						return current.hp==1&&get.attitude(player,current)>0;
					});
					player.chooseButton(dialog).ai=function(button){
						if(!player.hasFriend()&&button.link[2]=='hsqizhou_tu') return 0;
						if(player.isHealthy()&&button.link[2]=='hsqizhou_shui') return 0;
						if(shui&&button.link[2]=='hsqizhou_shui') return 3;
						if(tu&&button.link[2]=='hsqizhou_tu') return 2;
						return Math.random();
					};
					'step 1'
					if(result.buttons){
						player.logSkill('kqizhou');
						player.gain(game.createCard(result.buttons[0].link[2]),'draw');
					}
				},
				group:'kqizhou_add',
				subSkill:{
					add:{
						trigger:{player:'useCard'},
						silent:true,
						filter(event,player){
							return _status.currentPhase==player&&get.type(event.card,'trick')=='trick';
						},
						content(){
							player.storage.kqizhou=true;
						}
					}
				}
			},
			jingcu:{
				enable:'phaseUse',
				filter(event,player){
					return player.maxHp>1;
				},
				content(){
					'step 0'
					player.loseMaxHp(true);
					'step 1'
					player.draw(2);
				},
				ai:{
					order:1.5,
					threaten:1.4,
					result:{
						player(player){
							if(player.isDamaged()) return 1;
							if(player.hp>=3&&!player.needsToDiscard(2)) return 1;
							return 0;
						}
					}
				},
			},
			shengzhang:{
				trigger:{player:'phaseDiscardEnd'},
				forced:true,
				filter(event,player){
					return event.cards&&event.cards.length>0;
				},
				content(){
					player.gainMaxHp(true);
				}
			},
			pyuhuo:{
				unique:true,
				skillAnimation:true,
				animationColor:'fire',
				trigger:{player:'dying'},
				priority:10,
				filter(event,player){
					return player.storage.pyuhuo!='over';
				},
				forced:true,
				content(){
					'step 0'
					player.discard(player.getCards('hej'));
					'step 1'
					player.link(false);
					'step 2'
					player.turnOver(false);
					'step 3'
					if(player.storage.pyuhuo=='mid'){
						player.storage.pyuhuo='over';
						player.awakenSkill('pyuhuo');
						player.hp=6;
						player.maxHp=6;
						player.draw(6);
						player.setAvatar('hs_pyros','hs_pyros2');
					}
					else{
						player.storage.pyuhuo='mid';
						player.hp=4;
						player.maxHp=4;
						player.draw(4);
						player.setAvatar('hs_pyros','hs_pyros1');
					}
				},
				ai:{
					threaten(player,target){
						if(target.storage.pyuhuo=='mid') return 0.6;
						if(target.storage.pyuhuo=='over') return 1;
						return 0.4;
					}
				}
			},
			mengye:{
				trigger:{player:'phaseEnd'},
				direct:true,
				filter(event,player){
					return game.hasPlayer(function(current){
						return current!=player&&current.countCards('h');
					});
				},
				content(){
					'step 0'
					player.chooseTarget(get.prompt('mengye'),function(card,player,target){
						return target.countCards('h')>0;
					}).ai=function(target){
						if(target.hasSkillTag('nodu')) return get.attitude(player,target)*1.5;
						if(target.hasCard(function(card){
							return card.name!='du';
						})){
							return -get.attitude(player,target);
						}
						return -get.attitude(player,target)/5;
					}
					'step 1'
					if(result.bool){
						var target=result.targets[0];
						player.logSkill('mengye',target);
						var card=target.getCards('h',function(card){
							return card.name!='du';
						}).randomGet();
						if(card){
							card.init([card.suit,card.number,'du']);
						}
						target.changeHujia();
						game.log(target,'将一张手牌转化为',{name:'du'});
					}
				},
				ai:{
					threaten:1.5
				}
			},
			mengye_old:{
				trigger:{player:'phaseAfter'},
				priority:-50,
				direct:true,
				filter(event,player){
					if(get.mode()=='identity'&&_status.mode=='zhong'&&
						game.zhu&&!game.zhu.isZhu&&player==game.zhong){
						return false;
					}
					if(_status.noswap){
						return false;
					}
					return !player.isTurnedOver();
				},
				content(){
					'step 0'
					player.chooseTarget(get.prompt('mengye'),function(card,player,target){
						if(target==player){
							return false;
						}
						if(get.mode()=='identity'&&_status.mode=='zhong'&&game.zhu&&!game.zhu.isZhu){
							return target==game.zhong;
						}
						if(target.identity=='zhu'||get.is.jun(target)) return false;
						return true;
					}).ai=function(target){
						var att=-get.attitude(player,target);
						if(att<=0) return 0;
						if(target.needsToDiscard()) att+=3;
						else if(target.needsToDiscard(1)) att++;
						else if(target.countCards()<=3){
							return 0;
						}
						return att+target.countCards('h')+get.threaten(target);
					};
					'step 1'
					if(result.bool){
						var target=result.targets[0];
						player.logSkill('mengye',target);
						target.storage.mengye2=player;
						target.storage.mengye4=target.ai.shown;
						target.addSkill('mengye2');
						event.target=target;
						player.turnOver();
					}
					else{
						event.finish();
					}
					'step 2'
					game.delay();
					'step 3'
					var target=event.target;
					if(player==game.me){
						game.swapPlayerAuto(target);
						target.storage.mengye3=true;
					}
					else{
						target.addSkill('mad');
						target.unmarkSkill('mad');
					}
					player.out('mengye');
					target.insertPhase();
				},
				ai:{
					threaten:2
				}
			},
			mengye2:{
				temp:true,
				mark:'character',
				vanish:true,
				intro:{
					content:'由$控制本回合行动'
				},
				init(player){
					player.ai.modAttitudeFrom=function(from,to){
						return get.attitude(player.storage.mengye2,to);
					}
					player.ai.modAttitudeTo=function(from,to,att){
						if(from!=to) return 0;
						return att;
					}
				},
				onremove(player){
					delete player.ai.modAttitudeFrom;
					delete player.ai.modAttitudeTo;
					delete player.storage.mengye2;
					delete player.storage.mengye3;
					delete player.storage.mengye4;
				},
				trigger:{player:['phaseAfter','dieBegin']},
				forced:true,
				popup:false,
				content(){
					player.storage.mengye2.in('mengye');
					if(player==game.me&&player.storage.mengye3){
						game.swapPlayerAuto(player.storage.mengye2);
					}
					if(typeof player.ai.shown=='number'){
						player.ai.shown=player.storage.mengye4;
					}
					player.removeSkill('mad');
					player.removeSkill('mengye2');
				}
			},
			mengye3:{},
			lianzhan:{
				trigger:{source:'damageEnd'},
				forced:true,
				content(){
					if(player.getStat().damage>trigger.num){
						player.gainMaxHp();
						player.recover();
					}
					else{
						player.draw(2);
					}
				},
				ai:{
					damageBonus:true
				}
			},
			lianzhan2:{},
			kuixin:{
				trigger:{player:'phaseEnd'},
				direct:true,
				filter(event,player){
					return game.hasPlayer(function(current){
						if(current==player) return false;
						var nh=current.countCards('h');
						return nh&&nh>=player.countCards('h');
					});
				},
				content(){
					'step 0'
					player.chooseTarget(get.prompt('kuixin'),function(card,player,target){
						if(target==player) return false;
						var nh=target.countCards('h');
						return nh&&nh>=player.countCards('h');
					}).ai=function(target){
						var att=get.attitude(player,target);
						if(target.hasSkillTag('noe')){
							att/=3;
						}
						return -att;
					}
					'step 1'
					if(result.bool){
						var target=result.targets[0];
						var card=target.getCards('h').randomGet();
						if(card){
							player.logSkill('kuixin',target);
							player.gain(card,target);
							target.$giveAuto(card,player);
						}
					}
				}
			},
			fuhua:{
				enable:'phaseUse',
				filterCard:{name:'du'},
				check(){return 1},
				filterTarget(card,player,target){
					return !target.hasSkill('moxie')&&!target.hasSkill('fuhua2');
				},
				filter(event,player){
					return player.countCards('h','du')>0;
				},
				discard:false,
				prepare:'give',
				content(){
					'step 0'
					target.gain(cards,player);
					var choice=1;
					if(get.attitude(target,player)>0||(target.hp<=1&&!target.hasSha())){
						choice=0;
					}
					target.chooseControl(function(){
						return choice;
					}).set('choiceList',['获得技能魔血，每个出牌阶段开始时需交给'+get.translation(player)+'一张牌',
					'视为'+get.translation(player)+'对你使用一张决斗，若你赢，本局不能再成为腐化目标']);
					'step 1'
					if(result.index==0){
						target.storage.fuhua2=player;
						target.addSkill('fuhua2');
						target.addSkill('moxie');
					}
					else{
						player.useCard({name:'juedou'},target);
					}
				},
				ai:{
					threaten:1.5,
					order:8,
					expos:0.2,
					result:{
						player(player,target){
							if(player.countCards('h')<=2) return 0;
							if(get.attitude(target,player)>0) return 1;
							if(get.effect(target,{name:'juedou'},player,player)>0) return 1.5;
							return 0;
						}
					}
				}
			},
			fuhua2:{
				trigger:{player:'phaseEnd'},
				forced:true,
				priority:1,
				filter(event,player){
					return player.storage.fuhua2.isIn()&&player.countCards('h')>0;
				},
				mark:'character',
				intro:{
					content(storage){
						return '每个结束阶段需交给'+get.translation(storage)+'一张手牌';
					}
				},
				content(){
					'step 0'
					player.chooseCard('h',true,'交给'+get.translation(player.storage.fuhua2)+'一张手牌');
					'step 1'
					if(result.bool){
						player.storage.fuhua2.gain(result.cards,player);
						player.$give(result.cards,player.storage.fuhua2);
						player.line(player.storage.fuhua2,'green');
					}
				},
				group:'fuhua2_remove',
				onremove:true,
				subSkill:{
					remove:{
						trigger:{global:'dieAfter'},
						forced:true,
						popup:false,
						filter(event,player){
							return event.player==player.storage.fuhua2;
						},
						content(){
							player.removeSkill('fuhua2');
						}
					}
				}
			},
			fuhua3:{
				trigger:{player:'damageBefore'},
				forced:true,
				popup:false,
				filter(event,player){
					var evt=event.getParent(3);
					return evt.name=='fuhua'&&evt.target==event.source;
				},
				content(){
					trigger.getParent(3).target.storage.fuhua_failed=true;
				}
			},
			moxie:{
				trigger:{player:'loseHpBegin'},
				forced:true,
				filter:(event)=>event.type=='du',
				content(){
					trigger.cancel();
					player.draw(2);
				},
				ai:{
					threaten:1.2,
					nodu:true,
					usedu:true,
				},
				group:'moxie_use',
				subSkill:{
					use:{
						trigger:{player:'phaseEnd'},
						forced:true,
						filter(event,player){
							return player.countCards('h')>0;
						},
						content(){
							var hs=player.getCards('h');
							for(var i=0;i<hs.length;i++){
								if(hs[i].name=='du'){
									hs.splice(i--,1);
								}
							}
							if(hs.length){
								var card=hs.randomGet();
								card.init([card.suit,card.number,'du']);
								game.log(player,'将一张手牌转化为',{name:'du'});
							}
						}
					}
				}
			},
			moxue_old:{
				trigger:{player:'phaseEnd'},
				filter(event,player){
					return game.hasPlayer(function(current){
						return current.hp>player.hp;
					});
				},
				logTarget(event,player){
					return game.filterPlayer(function(current){
						return current.hp>player.hp;
					});
				},
				content(){
					'step 0'
					event.targets=game.filterPlayer(function(current){
						return current.hp>player.hp;
					});
					event.targets.sortBySeat();
					'step 1'
					if(event.targets.length){
						event.target=event.targets.shift();
						if(event.target.countCards('he',{color:'black'})){
							event.target.chooseCard('he','交给'+get.translation(player)+'一张黑色牌，或失去1点体力',{color:'black'}).ai=function(card){
								if(get.attitude(event.target,player)>0) return 10-get.value(card);
								return 7-get.value(card);
							}
						}
						else{
							event.target.loseHp();
							event.redo();
						}
					}
					else{
						event.finish();
					}
					'step 2'
					if(result.bool){
						player.gain(result.cards,event.target);
						if(get.position(result.cards[0])=='e'){
							event.target.$give(result.cards,player);
						}
						else{
							event.target.$give(result.cards.length,player);
						}
					}
					else{
						event.target.loseHp();
					}
					event.goto(1);
				}
			},
			gfuhun:{
				trigger:{player:'phaseEnd'},
				direct:true,
				filter(event,player){
					return player.countCards('h')>0&&!player.isTurnedOver();
				},
				content(){
					'step 0'
					player.chooseTarget(get.prompt('gfuhun'),function(card,player,target){
						return target!=player&&target.countCards('h')>0;
					}).ai=function(target){
						return -get.attitude(player,target);
					}
					'step 1'
					if(result.bool){
						player.logSkill('gfuhun',result.targets);
						event.target=result.targets[0];
						player.chooseToCompare(event.target);
					}
					else{
						event.finish();
					}
					'step 2'
					if(result.bool){
						event.target.goMad({player:'phaseAfter'});
						if(!player.isTurnedOver()) player.turnOver();
					}
				},
				ai:{
					expose:0.2,
					threaten:1.5
				}
			},
			qianhou:{
				trigger:{player:'phaseBegin'},
				forced:true,
				content(){
					'step 0'
					var list=[];
					for(var i=0;i<lib.inpile.length;i++){
						if(lib.filter.filterCard({name:lib.inpile[i]},player)){
							var info=lib.card[lib.inpile[i]];
							if(info.type=='trick'&&!info.multitarget&&!info.notarget){
								if(Array.isArray(info.selectTarget)){
									if(info.selectTarget[0]>0&&info.selectTarget[1]>=info.selectTarget[0]){
										list.push(lib.inpile[i]);
									}
								}
								else if(typeof info.selectTarget=='number'){
									list.push(lib.inpile[i]);
								}
							}
						}
					}
					while(list.length){
						var card={name:list.randomRemove()};
						var info=get.info(card);
						var targets=game.filterPlayer(function(current){
							return lib.filter.filterTarget(card,player,current);
						});
						if(targets.length){
							targets.sort(lib.sort.seat);
							if(info.selectTarget!=-1){
								var num=info.selectTarget;
								if(Array.isArray(num)){
									if(targets.length<num[0]) continue;
									num=num[0]+Math.floor(Math.random()*(num[1]-num[0]+1));
								}
								else{
									if(targets.length<num) continue;
								}
								targets=targets.randomGets(num);
							}
							player.useCard(card,targets,'noai');
							if(targets.length==1&&targets[0]!=player){
								event.cardname=card.name;
							}
							break;
						}
					}
					'step 1'
					if(player.countCards('h')&&event.cardname){
						player.chooseToDiscard('是否弃置一张手牌并获得'+get.translation(event.cardname)+'？','h').ai=function(card){
							return get.value({name:event.cardname})-get.value(card);
						}
					}
					else{
						event.finish();
					}
					'step 2'
					if(result.bool){
						var card=result.cards[0];
						var fakecard=game.createCard(event.cardname,card.suit,card.number);
						player.gain(fakecard,'gain2','log');
					}
				}
			},
			hlongyi:{
				mod:{
					ignoredHandcard(card,player){
						if(get.color(card)=='black'){
							return true;
						}
					}
				},
			},
			zhongji:{
				trigger:{source:'damageBegin'},
				direct:true,
				filter(event,player){
					return player.countCards('h',{color:'black'})>0;
				},
				content(){
					"step 0"
					var next=player.chooseToDiscard(get.prompt('zhongji',trigger.player),{color:'black'});
					next.logSkill=['zhongji',trigger.player];
					next.ai=function(card){
						if(get.attitude(player,trigger.player)<0){
							return 7-get.value(card);
						}
						return -1;
					}
					"step 1"
					if(result.bool){
						trigger.num++;
					}
				},
				ai:{
					threaten:1.3
				}
			},
			fuwen:{
				trigger:{player:'phaseDiscardEnd'},
				frequent:true,
				filter(event,player){
					if(event.cards){
						for(var i=0;i<event.cards.length;i++){
							if(get.type(event.cards[i],'trick')=='trick') return true;
						}
					}
					return false;
				},
				content(){
					player.changeHujia();
				},
			},
			jinzhou:{
				trigger:{player:'phaseEnd'},
				direct:true,
				filter(event,player){
					return player.countCards('h',{suit:'spade'})>0;
				},
				content(){
					'step 0'
					player.chooseTarget(get.prompt('jinzhou'),function(card,player,target){
						return target!=player&&!target.hasSkill('fengyin');
					}).ai=function(target){
						var att=get.attitude(player,target);
						if(att>=0) return 0;
						var skills=target.getSkills();
						for(var i=0;i<skills.length;i++){
							if(!get.is.locked(skills[i])){
								if(target.hasSkillTag('maixie')) return 2;
								return get.threaten(target);
							}
						}
						return 0;
					}
					'step 1'
					if(result.bool){
						player.logSkill('jinzhou',result.targets);
						result.targets[0].addTempSkill('fengyin',{player:'phaseAfter'});
					}
				},
				ai:{
					expose:0.2,
					threaten:1.4
				}
			},
			midian:{
				enable:'phaseUse',
				usable:1,
				filter(event,player){
					return player.countCards('h',{type:['trick','delay']})>0;
				},
				filterCard:{type:['trick','delay']},
				check(card){
					return 10-get.value(card);
				},
				content(){
					var list=get.inpile('trick','trick');
					var list2=[];
					for(var i=0;i<3;i++){
						list2.push(game.createCard(list.randomGet()));
					}
					player.gain(list2,'draw');
				},
				ai:{
					order:9.8,
					threaten:1.8,
					result:{
						player:1
					}
				}
			},
			xingluo:{
				trigger:{player:'phaseBegin'},
				direct:true,
				filter(event,player){
					return !player.isMaxHandcard();
				},
				content(){
					'step 0'
					var nh=player.countCards('h');
					var num=game.countPlayer(function(current){
						return current.countCards('h')>nh;
					});
					player.chooseTarget(get.prompt('xingluo'),[1,num],function(card,player,target){
						return target.countCards('h')>nh;
					}).ai=function(target){
						return 0.5-get.attitude(player,target);
					}
					'step 1'
					if(result.bool){
						event.cards=[];
						event.list=result.targets.slice(0);
						event.list.sort(lib.sort.seat);
						player.logSkill('xingluo',result.targets);
					}
					else{
						event.finish();
					}
					'step 2'
					if(event.list.length){
						event.list.shift().chooseToDiscard('h',true);
					}
					else{
						event.goto(4);
					}
					'step 3'
					if(result.bool&&result.cards.length){
						event.cards.push(result.cards[0]);
					}
					event.goto(2);
					'step 4'
					if(event.cards.length){
						player.chooseCardButton('选择一张加入手牌',event.cards).ai=function(button){
							return get.value(button.link);
						};
					}
					else{
						event.finish();
					}
					'step 5'
					if(result.bool){
						player.gain(result.links,'gain2');
					}
				},
				ai:{
					expose:0.2
				}
			},
			yuelu:{
				enable:'chooseToUse',
				filter(event,player){
					return event.type=='dying'&&player.countCards('he',{color:'black'})>0;
				},
				// alter:true,
				filterCard:{color:'black'},
				position:'he',
				check(card){
					return 11-get.value(card);
				},
				filterTarget(card,player,target){
					return target==_status.event.dying;
				},
				selectTarget:-1,
				content(){
					target.recover();
					if(!get.is.altered('yuelu')) target.changeHujia();
				},
				ai:{
					order:10,
					skillTagFilter(player){
						if(player.countCards('he',{color:'black'})==0) return false;
					},
					save:true,
					result:{
						target:3
					},
					threaten:2.5
				},
			},
			yushou:{
				enable:'phaseUse',
				filterCard:true,
				position:'he',
				check(card){
					var player=_status.event.player;
					var num=0;
					if(player.hasSkill('yushou_misha')) num+=1.5;
					if(player.hasSkill('yushou_huofu')) num+=1.5;
					if(player.hasSkill('yushou_leiouke')) num+=1.5;
					return 5-num-get.value(card);
				},
				filter(event,player){
					if(player.hasSkill('yushou_misha')&&player.hasSkill('yushou_huofu')&&player.hasSkill('yushou_leiouke')) return false;
					return true;
				},
				content(){
					if(!lib.character.stone_misha){
						lib.character.stone_misha=['male','shu',3,['lschaofeng'],['minskin','stone','mode:stone'],[3,3,'hunter']];
					}
					if(!lib.character.stone_huofu){
						lib.character.stone_huofu=['male','qun',2,['stone_chongfeng'],['minskin','stone','mode:stone'],[3,4,'hunter']];
					}
					if(!lib.character.stone_leiouke){
						lib.character.stone_leiouke=['male','shu',2,['hunter_zhanhuo'],['minskin','stone','mode:stone'],[3,1,'hunter']];
					}
					var list=['misha','leiouke','huofu'];
					for(var i=0;i<list.length;i++){
						if(player.hasSkill('yushou_'+list[i])){
							list.splice(i--,1);
						}
					}
					var skill=list.randomGet();
					var name='yushou_'+skill;
					player.addSkill(name);
					player.markSkillCharacter(name,'stone_'+skill,lib.translate[name],lib.translate[name+'_info']);
				},
				ai:{
					order:9.5,
					result:{
						player:1
					}
				},
				group:'yushou_lose'
			},
			yushou_lose:{
				trigger:{player:'phaseBegin'},
				silent:true,
				content(){
					var list=['yushou_misha','yushou_huofu','yushou_leiouke'];
					var skills=player.getSkills();
					for(var i=0;i<list.length;i++){
						if(!skills.includes(list[i])) list.splice(i--,1);
					}
					if(list.length){
						player.removeSkill(list.randomGet());
					}
				}
			},
			yushou_misha:{
				trigger:{player:'damageEnd'},
				forced:true,
				filter(event,player){
					return event.num>=1;
				},
				content(){
					player.changeHujia();
				},
				ai:{
					effect:{
						target(card,player,target){
							if(get.tag(card,'damage')){
								if(player.hasSkillTag('jueqing',false,target)) return;
								return 0.6;
							}
						}
					}
				},
			},
			yushou_huofu:{
				enable:'phaseUse',
				viewAs:{name:'juedou'},
				filterCard:{color:'black'},
				position:'he',
				viewAsFilter(player){
					if(!player.countCards('he',{color:'black'})) return false;
				},
				check(card){
					return 6-get.value(card);
				},
				ai:{
					basic:{
						order:10
					}
				}
			},
			yushou_leiouke:{
				trigger:{source:'damageBegin'},
				forced:true,
				usable:1,
				content(){
					trigger.num++;
				}
			},
			qingzun:{
				// alter:true,
				subSkill:{
					count:{
						trigger:{player:'useCard'},
						silent:true,
						filter(event,player){
							return event.card.name.indexOf('hsqingyu_')==0;
						},
						content(){
							player.storage.qingzun++;
							player.updateMarks();
						}
					},
					draw1:{
						trigger:{player:'phaseBegin'},
						filter(event,player){
							if(get.is.altered('qingzun')) return player.storage.qingzun>=3;
							return player.storage.qingzun>=2;
						},
						frequent:true,
						content(){
							player.draw();
						}
					},
					draw2:{
						trigger:{player:'phaseEnd'},
						filter(event,player){
							if(get.is.altered('qingzun')) return player.storage.qingzun>=9;
							return player.storage.qingzun>=6;
						},
						frequent:true,
						content(){
							player.draw();
						}
					},
				},
				mod:{
					maxHandcard(player,num){
						return num+player.storage.qingzun;
					}
				},
				init(player){
					player.storage.qingzun=0;
				},
				mark:true,
				marktext:'玉',
				intro:{
					content(storage,player){
						if(!storage) return '未使用过青玉牌';
						var str='手牌上限+'+storage;
						var num1,num2;
						if(get.is.altered('qingzun')){
							num1=3;
							num2=9;
						}
						else{
							num1=2;
							num2=6;
						}
						if(storage>=num2){
							str+='；准备阶段和结束阶段，你可以摸一张牌'
						}
						else if(storage>=num1){
							str+='；准备阶段，你可以摸一张牌'
						}
						return str;
					}
				},
				group:['qingzun_count','qingzun_draw1','qingzun_draw2'],
			},
			ayuling:{
				trigger:{player:'damageEnd'},
				frequent:true,
				content(){
					var list=['feibiao','hufu','zhao','zhanfang','shandian'];
					player.gain(game.createCard('hsqingyu_'+list.randomGet()),'draw');
				},
				ai:{
					maixie:true,
					maixie_hp:true,
					effect:{
						target(card,player,target){
							if(get.tag(card,'damage')){
								if(player.hasSkillTag('jueqing',false,target)) return [1,-2];
								if(!target.hasFriend()) return;
								if(target.hp>=4) return [1,get.tag(card,'damage')*2];
								if(target.hp==3) return [1,get.tag(card,'damage')*1.5];
								if(target.hp==2) return [1,get.tag(card,'damage')*0.5];
							}
						}
					}
				}
			},
			aoshu:{
				enable:'phaseUse',
				usable:1,
				position:'he',
				filterCard(card){
					return get.suit(card)=='spade';
				},
				viewAs:{name:'wuzhong'},
				viewAsFilter(player){
					if(!player.countCards('he',{suit:'spade'})) return false;
				},
				prompt:'将一张黑桃牌当作无中生有使用',
				check(card){return 7-get.value(card)},
				ai:{
					threaten:1.4,
					order:9,
				}
			},
			bzhuiji:{
				trigger:{global:'dieAfter'},
				check(event,player){
					return get.attitude(player,event.source)<=0;
				},
				filter(event,player){
					return event.source&&event.source.isAlive()&&event.source!=player;
				},
				content(){
					player.draw(2);
					player.useCard({name:'juedou'},trigger.source);
				},
				ai:{
					threaten:1.5,
					expose:0.1
				}
			},
			lianjin_old:{
				enable:'phaseUse',
				usable:2,
				filterCard:true,
				check(card){
					return 7-get.value(card);
				},
				content(){
					'step 0'
					var list=get.inpile('trick');
					list=list.randomGets(3);
					for(var i=0;i<list.length;i++){
						list[i]=['锦囊','',list[i]];
					}
					var dialog=ui.create.dialog('选择一张锦囊牌加入你的手牌',[list,'vcard'],'hidden');
					player.chooseButton(dialog,true);
					'step 1'
					if(result.buttons){
						player.gain(game.createCard(result.buttons[0].link[2]),'draw');
					}
				},
				ai:{
					order:9,
					result:{
						player:1
					}
				}
			},
			lianjin:{
				enable:'phaseUse',
				usable:1,
				filterCard(card){
					return get.type(card)!='hsyaoshui';
				},
				check(card){
					return 8-get.value(card)
				},
				position:'he',
				// discard:false,
				// lose:false,
				// delay:false,
				content(){
					'step 0'
					var names=[];
					var inpile=lib.inpile.slice(0);
					inpile.randomSort();
					var single=false;
					var equip=Math.random()<0.5;
					var equips=[];
					for(var i=0;i<inpile.length;i++){
						if(lib.inpile[i]=='chuansongmen') continue;
						var info=lib.card[inpile[i]];
						if(!info.enable) continue;
						if(!info.filterTarget) continue;
						if(typeof info.selectTarget=='function') continue;
						if(inpile[i].indexOf('_')!=-1) continue;
						if(info.type=='equip'){
							equips.push(inpile[i]);
							continue;
						}
						if(equip&&names.length>=2) continue;
						if(names.length>=3) continue;
						var select=get.select(info.selectTarget);
						if(select[0]==-1&&select[1]==-1){
							names.push(inpile[i]);
							if(info.modTarget) single=true;
						}
						else if(select[0]==1&&select[1]==1){
							names.push(inpile[i]);
							single=true;
						}
					}
					if(equip){
						names.push(equips.randomGet());
					}
					names.sort(lib.sort.name);
					var name='hsyaoshui_'+names[0]+'_'+names[1]+'_'+names[2];
					if(!lib.card[name]){
						lib.card[name]=get.copy(lib.skill.lianjin.template);
						lib.card[name].names=names;
						lib.card[name].selectTarget=single?1:-1;
						lib.translate[name]='药水';
						lib.translate[name+'_info']=get.translation(names[0])+'、'+
						get.translation(names[1])+'、'+get.translation(names[2]);
					}
					var fakecard=game.createCard(name,cards[0].suit,cards[0].number);
					player.gain(fakecard,'gain2');
					// cards[0].style.transitionDuration='0.2s';
					// ui.refresh(cards[0]);
					// cards[0].classList.add('opaque');
					// event.cardname=name;
					// if(player!=game.me){
					// 	var fakecard=game.createCard(name);
					// 	fakecard.node.info.remove();
					// 	player.$draw(fakecard);
					// }
					// game.delay(0,200);
					// stp 1
					// cards[0].style.transitionDuration='0s';
					// ui.refresh(cards[0]);
					// cards[0].classList.remove('fullskin');
					// cards[0].init([cards[0].suit,cards[0].number,event.cardname]);
					// game.delay(0,100);
					// stp 2
					// cards[0].style.transitionDuration='';
					// ui.refresh(cards[0]);
					// cards[0].classList.remove('opaque');
					// game.delay(0,200);
				},
				template:{
					type:'hsyaoshui',
					enable:true,
					fullimage:true,
					image:'card/hsyaoshui',
					vanish:true,
					derivation:'hs_kazhakusi',
					multitarget:true,
					multiline:true,
					filterTarget(card,player,target){
						var info=get.info(card);
						var names=info.names;
						for(var i=0;i<names.length;i++){
							var info2=lib.card[names[i]];
							if(get.select(info2.selectTarget)[0]==-1&&!info2.modTarget) continue;
							if(!lib.filter.targetEnabled2({name:names[i]},player,target)) return false;
						}
						return true;
					},
					content(){
						'step 0'
						event.names=get.info(card).names.slice(0);
						'step 1'
						if(event.names.length){
							var name=event.names.shift();
							var info=lib.card[name];
							var targets=[];
							if(get.select(info.selectTarget)[0]==-1&&!info.modTarget){
								var targets=game.filterPlayer(function(current){
									return player.canUse(name,current);
								});
								targets.sort(lib.sort.seat);
							}
							else{
								if(target.isDead()){
									return;
								}
								targets.push(target);
							}
							player.useCard(game.createCard({name:name,suit:get.suit(card),number:card.number}),targets,'noai');
							player.addExpose(0.2);
							event.redo();
						}
					},
					ai:{
						order:9.1,
						threaten:1.5,
						result:{
							target(player,target,card){
								var info=get.info(card);
								if(!info) return 0;
								if(!Array.isArray(info.names)) return 0;
								var names=info.names;
								if(names.includes('xingjiegoutong')&&target.countCards('h')>=3) return -1;
								var num=0;
								for(var i=0;i<names.length;i++){
									var info2=lib.card[names[i]];
									if(get.select(info2.selectTarget)[0]==-1&&!info2.modTarget) continue;
									var eff=get.effect(target,{name:names[i]},player,target);
									if(eff>0){
										num++;
									}
									else if(eff<0){
										num-=0.9;
									}
								}
								return num;
							}
						}
					}
				},
				ai:{
					order:9,
					result:{
						player:1
					},
					threaten:1.4
				},
				group:'lianjin_discard',
				subSkill:{
					discard:{
						trigger:{player:'discardAfter'},
						forced:true,
						filter(event){
							for(var i=0;i<event.cards.length;i++){
								if(get.type(event.cards[i])=='hsyaoshui') return true;
							}
							return false;
						},
						content(){
							var list=[],cards=[];
							for(var i=0;i<trigger.cards.length;i++){
								if(get.type(trigger.cards[i])=='hsyaoshui'){
									list.push(trigger.cards[i]);
								}
							}
							for(var i=0;i<list.length;i++){
								var names=get.info(list[i]).names;
								if(names){
									cards.push(game.createCard(names.randomGet()));
								}
							}
							player.gain(cards,'draw2','log');
						}
					}
				}
			},
			shouji:{
				group:['shouji_begin','shouji_miss'],
				subSkill:{
					begin:{
						trigger:{player:'shaBegin'},
						frequent:true,
						usable:1,
						filter(event){
							return event.target.countCards('h')>0;
						},
						content(){
							player.gain(game.createCard(trigger.target.getCards('h').randomGet()),'draw');
						}
					},
					miss:{
						trigger:{player:'shaMiss'},
						frequent:true,
						usable:1,
						filter(event){
							return event.target.hasCard(function(card){
								return !get.info(card).unique;
							},'e');
						},
						content(){
							player.gain(game.createCard(trigger.target.getCards('e',function(card){
								return !get.info(card).unique;
							}).randomGet()),'draw');
						}
					}
				}
			},
			yingxi:{
				trigger:{player:'phaseEnd'},
				direct:true,
				filter(event,player){
					return !player.getStat('damage')&&player.countCards('he',{color:'black'})>0;
				},
				content(){
					'step 0'
					player.chooseCardTarget({
						prompt:get.prompt('yingxi'),
						filterCard:{color:'black'},
						filterTarget(card,player,target){
							return lib.filter.targetEnabled({name:'sha'},player,target);
						},
						position:'he',
						ai1(card){
							return 8-get.value(card);
						},
						ai2(target){
							return get.effect(target,{name:'sha'},player,player);
						}
					});
					'step 1'
					if(result.bool){
						player.useCard({name:'sha'},result.cards,result.targets,'yingxi');
					}
				},
				group:'yingxi2',
			},
			yingxi2:{
				trigger:{player:'shaBegin'},
				forced:true,
				popup:false,
				filter(event,player){
					return event.skill=='yingxi'&&event.target.isHealthy();
				},
				content(){
					trigger.directHit=true;
				}
			},
			hsguimou:{
				trigger:{player:'damageEnd'},
				check(event,player){
					return get.attitude(player,event.source)<=0;
				},
				filter(event,player){
					return event.source&&event.source.isAlive()&&event.source!=player&&event.source.countCards('h')>0;
				},
				logTarget:'source',
				content(){
					var card=trigger.source.getCards('h').randomGet();
					if(card){
						player.gain(card,trigger.source);
						if(get.color(card)=='black'){
							trigger.source.$give(card,player);
							event.redo();
						}
						else{
							trigger.source.$giveAuto(card,player);
						}
						game.delay(0.5);
					}
				},
				ai:{
					maixie:true,
					maixie_hp:true,
					maixie_defend:true,
					effect:{
						target(card,player,target){
							if(player.hasSkillTag('jueqing',false,target)) return [1,-2];
							if(!target.hasFriend()) return false;
							if(get.tag(card,'damage')&&player.countCards('h')>1) return [1,0,0,-1];
						}
					}
				}
			},
			peiyu:{
				trigger:{player:['phaseBegin']},
				direct:true,
				content(){
					'step 0'
					player.chooseTarget(get.prompt('peiyu'),function(card,player,target){
						for(var i=1;i<=8;i++){
							if(target.hasSkill('tuteng'+i)) return false;
						}
						return true;
					}).ai=function(target){
						if(player==target&&get.attitude(player,target)>0&&event.parent.triggername=='phaseBegin'){
							return get.attitude(player,target)+10;
						}
						return get.attitude(player,target);
					}
					'step 1'
					if(result.bool){
						player.logSkill('peiyu',result.targets);
						var rand=['tuteng1','tuteng2','tuteng3','tuteng4',
							'tuteng5','tuteng6','tuteng7','tuteng8'];
						result.targets[0].addAdditionalSkill('peiyu',['peiyu2',rand.randomGet()]);
					}
				}
			},
			peiyu2:{
				trigger:{player:'damageAfter'},
				silent:true,
				content(){
					player.removeAdditionalSkill('peiyu');
				}
			},
			peiyu_old:{
				enable:'phaseUse',
				filterCard:true,
				position:'he',
				filterTarget:true,
				check(card){
					return 6-get.value(card);
				},
				content(){
					'step 0'
					var rand=['tuteng1','tuteng2','tuteng3','tuteng4',
						'tuteng5','tuteng6','tuteng7','tuteng8'];
					var rand2=[];
					for(var i=0;i<target.skills.length;i++){
						if(rand.includes(target.skills[i])){
							rand.remove(target.skills[i]);
							rand2.push(target.skills[i]);
						}
					}
					if(!rand.length){
						event.finish();
						return;
					}
					if(!target.storage.peiyu){
						target.storage.peiyu={};
					}
					for(var i in target.storage.peiyu){
						if(target.storage.peiyu[i]==player){
							delete target.storage.peiyu[i];
						}
					}
					if(rand2.length){
						var randx=[];
						var rand2x=[];
						if(target.isUnderControl(true)){
							var dialog=ui.create.dialog();
							for(var i=0;i<rand.length;i++){
								randx[i]=['','',rand[i]];
							}
							for(var i=0;i<rand2.length;i++){
								rand2x[i]=['','',rand2[i]];
							}
							dialog.add('选择一个图腾');
							dialog.add([randx,'vcard']);
							dialog.add('替换一个已有图腾');
							dialog.add([rand2x,'vcard']);
							target.chooseButton(dialog,2,true).filterButton=function(button){
								if(ui.selected.buttons.length){
									var current=ui.selected.buttons[0].name;
									if(rand.includes(current)){
										return rand2.includes(button.name);
									}
									else{
										return rand.includes(button.name);
									}
								}
								return true;
							};
							for(var i=0;i<dialog.buttons.length;i++){
								var item=dialog.buttons[i]
								if(i==4){
									item.parentNode.insertBefore(document.createElement('br'),item);
								}
								item.style.zoom=0.7;
							}
						}
						else{
							var gain;
							if(target.hp<target.maxHp){
								if(rand.includes('tuteng1')){
									gain='tuteng1';
								}
								else if(rand.includes('tuteng3')){
									gain='tuteng3';
								}
								else{
									gain=rand.randomGet();
								}
								target.removeSkill(rand2.randomGet())
							}
							else{
								if(rand2.includes('tuteng1')){
									gain=rand.randomGet();
									target.removeSkill('tuteng1');
								}
								else{
									if(rand.length>1){
										rand.remove('tuteng1');
									}
									gain=rand.randomGet();
									target.removeSkill(rand2.randomGet())
								}
							}
							target.addSkill(gain);
							target.storage.peiyu[gain]=player;
							game.delay();
							event.finish();
						}
					}
					else{
						var gain=rand.randomGet();
						target.addSkill(gain);
						target.storage.peiyu[gain]=player;
						game.delay();
						event.finish();
					}
					'step 1'
					var skill1=result.buttons[0].name;
					var skill2=result.buttons[1].name;
					if(target.hasSkill(skill1)){
						target.removeSkill(skill1);
						target.addSkill(skill2);
						target.storage.peiyu[skill2]=player;
					}
					else{
						target.removeSkill(skill2);
						target.addSkill(skill1);
						target.storage.peiyu[skill1]=player;
					}
				},
				ai:{
					expose:0.2,
					order:5,
					result:{
						target(player,target){
							for(var i=1;i<=8;i++){
								if(target.hasSkill('tuteng'+i)) return 0;
							}
							return 1;
						}
					}
				},
				group:'peiyu_old2'
			},
			peiyu_old2:{
				trigger:{player:'dieBegin'},
				forced:true,
				popup:false,
				content(){
					game.countPlayer(function(current){
						for(var j in current.storage.peiyu){
							if(current.storage.peiyu[j]==player){
								current.removeSkill(j);
							}
						}
					});
				}
			},
			wzhanyi:{
				trigger:{player:'phaseUseBefore'},
				check(event,player){
					return player.countCards('h')+2<=player.hp;
				},
				content(){
					'step 0'
					event.cards=get.cards(3);
					trigger.cancel();
					player.$draw(event.cards.slice(0));
					for(var i=0;i<event.cards.length;i++){
						if(get.type(event.cards[i])=='equip'){
							player.equip(event.cards[i]);
							event.cards.splice(i--,1);
						}
					}
					player.gain(event.cards);
					'step 1'
					if(player.countCards('h','sha')){
						player.chooseToUse('战意：使用一张杀').filterCard=function(card){
							return card.name=='sha'&&get.itemtype(card)=='card';
						}
					}
					else{
						event.finish();
					}
					'step 2'
					if(result.bool){
						event.goto(1);
					}
				}
			},
			shengteng:{
				trigger:{source:'damageEnd'},
				forced:true,
				filter(event){
					return event.card&&get.type(event.card)=='trick';
				},
				content(){
					player.gainMaxHp(true);
					player.recover();
				},
			},
			yuansu:{
				enable:'phaseUse',
				usable:1,
				filter(event,player){
					return player.maxHp-player.hp>=3;
				},
				filterTarget(card,player,target){
					return player.canUse('yuansuhuimie',target);
				},
				selectTarget:-1,
				multitarget:true,
				multiline:true,
				line:'thunder',
				content(){
					player.maxHp=player.hp;
					player.update();
					targets.sort(lib.sort.seat);
					player.useCard({name:'yuansuhuimie'},targets).animate=false;
				}
			},
			chouhuo:{
				unique:true,
				trigger:{player:'phaseBegin'},
				forced:true,
				skillAnimation:true,
				animationColor:'fire',
				filter(event,player){
					if(player.storage.nuyan&&player.storage.nuyan.length){
						var num=0;
						for(var i=0;i<lib.inpile.length;i++){
							if(get.tag({name:lib.inpile[i]},'damage')){
								num++;
							}
						}
						return num<=player.storage.nuyan.length;
					}
					return false;
				},
				content(){
					player.loseMaxHp();
					player.changeHujia(2);
					player.removeSkill('nuyan');
					player.addSkill('nuyan2');
					player.awakenSkill('chouhuo');
				}
			},
			nuyan2:{
				enable:'phaseUse',
				usable:3,
				chooseButton:{
					dialog(event,player){
						var list=[];
						for(var i=0;i<lib.inpile.length;i++){
							if(get.tag({name:lib.inpile[i]},'damage')){
								list.push([get.type(lib.inpile[i]),'',lib.inpile[i]]);
							}
						}
						return ui.create.dialog([list,'vcard']);
					},
					filter(button,player){
						return lib.filter.filterCard({name:button.link[2]},player,_status.event.getParent());
					},
					check(button){
						var player=_status.event.player;
						var recover=0,lose=1;
						var players=game.filterPlayer();
						for(var i=0;i<players.length;i++){
							if(players[i].hp<players[i].maxHp){
								if(get.attitude(player,players[i])>0){
									if(players[i].hp<2){
										lose--;
										recover+=0.5;
									}
									lose--;
									recover++;
								}
								else if(get.attitude(player,players[i])<0){
									if(players[i].hp<2){
										lose++;
										recover-=0.5;
									}
									lose++;
									recover--;
								}
							}
							else{
								if(get.attitude(player,players[i])>0){
									lose--;
								}
								else if(get.attitude(player,players[i])<0){
									lose++;
								}
							}
						}
						if(button.link[2]=='nanman'||button.link[2]=='nanman'||button.link[2]=='yuansuhuimie'||
						button.link[2]=='chiyuxi'||button.link[2]=='jingleishan'){
							if(lose>recover&&lose>0){
								return 2;
							}
							else{
								return 0;
							}
						}
						return 1;
					},
					backup(links,player){
						return {
							filterCard(){return false},
							selectCard:-1,
							popname:true,
							viewAs:{name:links[0][2]},
							onuse(result,player){
								player.loseHp();
							}
						}
					},
					prompt(links,player){
						return '失去1点体力，视为使用一张'+get.translation(links[0][2]);
					}
				},
				ai:{
					order:6,
					result:{
						player(player){
							if(player.hp>1) return 1;
							return 0;
						}
					},
				}
			},
			nuyan:{
				enable:'phaseUse',
				usable:1,
				filter(event,player){
					return player.countCards('he',{color:'red'})>0
				},
				init(player){
					player.storage.nuyan=[];
				},
				chooseButton:{
					dialog(event,player){
						var list=[];
						for(var i=0;i<lib.inpile.length;i++){
							if(get.tag({name:lib.inpile[i]},'damage')){
								list.push([get.type(lib.inpile[i]),'',lib.inpile[i]]);
							}
						}
						return ui.create.dialog([list,'vcard']);
					},
					filter(button,player){
						if(player.storage.nuyan.includes(button.link[2])) return false;
						return lib.filter.filterCard({name:button.link[2]},player,_status.event.getParent());
					},
					check(button){
						var player=_status.event.player;
						var recover=0,lose=1;
						var players=game.filterPlayer();
						for(var i=0;i<players.length;i++){
							if(players[i].hp<players[i].maxHp){
								if(get.attitude(player,players[i])>0){
									if(players[i].hp<2){
										lose--;
										recover+=0.5;
									}
									lose--;
									recover++;
								}
								else if(get.attitude(player,players[i])<0){
									if(players[i].hp<2){
										lose++;
										recover-=0.5;
									}
									lose++;
									recover--;
								}
							}
							else{
								if(get.attitude(player,players[i])>0){
									lose--;
								}
								else if(get.attitude(player,players[i])<0){
									lose++;
								}
							}
						}
						if(button.link[2]=='nanman'||button.link[2]=='nanman'||button.link[2]=='yuansuhuimie'||
						button.link[2]=='chiyuxi'||button.link[2]=='jingleishan'){
							if(lose>recover&&lose>0){
								return 2;
							}
							else{
								return 0;
							}
						}
						return 1;
					},
					backup(links,player){
						return {
							filterCard:{color:'red'},
							selectCard:1,
							position:'he',
							popname:true,
							viewAs:{name:links[0][2]},
							ai1(card){
								return 6-get.value(card);
							},
							onuse(result,player){
								player.storage.nuyan.add(result.card.name);
							}
						}
					},
					prompt(links,player){
						return '将一张红色牌当作'+get.translation(links[0][2])+'使用';
					}
				},
				ai:{
					order:6,
					result:{
						player:1
					},
				}
			},
			duxin:{
				trigger:{player:['phaseBegin','phaseEnd']},
				frequent:true,
				filter(event,player){
					return !player.countCards('h',{type:'hsdusu'});
				},
				content(){
					var list=['hsdusu_xueji','hsdusu_huangxuecao','hsdusu_kuyecao','hsdusu_shinancao','hsdusu_huoyanhua'];
					if(typeof lib.cardType.hslingjian!='number'){
						list.remove('hsdusu_kuyecao');
					}
					var name=list.randomGet();
					if(name=='hsdusu_huoyanhua'){
						player.gain(game.createCard({name:name,nature:'fire'}),'draw');
					}
					else{
						player.gain(game.createCard(name),'draw');
					}
				},
				ai:{
					threaten:1.6
				}
			},
			oldduxin:{
				trigger:{player:['phaseBegin','phaseEnd']},
				frequent:true,
				content(){
					var list=['hsdusu_xueji','hsdusu_huangxuecao','hsdusu_kuyecao','hsdusu_shinancao','hsdusu_huoyanhua'];
					if(typeof lib.cardType.hslingjian!='number'){
						list.remove('hsdusu_kuyecao');
					}
					var name=list.randomGet();
					if(name=='hsdusu_huoyanhua'){
						player.gain(game.createCard({name:name,nature:'fire'}),'draw');
					}
					else{
						player.gain(game.createCard(name),'draw');
					}
				},
				ai:{
					threaten:1.6
				}
			},
			hsdusu_shinancao:{
				mark:true,
				marktext:'楠',
				nopop:true,
				intro:{
					content:'下一次造成的伤害+1'
				},
				logv:false,
				trigger:{source:'damageBegin'},
				forced:true,
				content(){
					trigger.num++;
					player.removeSkill('hsdusu_shinancao');
				}
			},
			kuangluan_old:{
				group:['kuangluan_count1','kuangluan_count2','kuangluan_use'],
				subSkill:{
					count1:{
						trigger:{player:'useCard'},
						silent:true,
						filter(event,player){
							return _status.currentPhase==player&&get.type(event.card)=='trick';
						},
						content(){
							player.storage.kuangluan++;
						}
					},
					count2:{
						trigger:{player:'phaseBegin'},
						silent:true,
						content(){
							player.storage.kuangluan=0;
						}
					},
					use:{
						trigger:{player:'phaseUseEnd'},
						forced:true,
						filter(event,player){
							return player.storage.kuangluan>0;
						},
						content(){
							var list=[];
							for(var i=0;i<lib.inpile.length;i++){
								if(lib.filter.filterCard({name:lib.inpile[i]},player)){
									var info=lib.card[lib.inpile[i]];
									if(info.type=='trick'&&!info.multitarget&&!info.notarget){
										if(Array.isArray(info.selectTarget)){
											if(info.selectTarget[0]>0&&info.selectTarget[1]>=info.selectTarget[0]){
												list.push(lib.inpile[i]);
											}
										}
										else if(typeof info.selectTarget=='number'){
											list.push(lib.inpile[i]);
										}
									}
								}
							}
							var n=player.storage.kuangluan;
							delete player.storage.kuangluan;
							while(list.length){
								var card={name:list.randomRemove()};
								var info=get.info(card);
								var targets=game.filterPlayer(function(current){
									return lib.filter.filterTarget(card,player,current);
								});
								if(targets.length){
									targets.sort(lib.sort.seat);
									if(info.selectTarget==-1){
										player.useCard(card,targets);
									}
									else{
										var num=info.selectTarget;
										if(Array.isArray(num)){
											if(targets.length<num[0]) continue;
											num=num[0]+Math.floor(Math.random()*(num[1]-num[0]+1));
										}
										else{
											if(targets.length<num) continue;
										}
										player.useCard(card,targets.randomGets(num));
									}
									if(--n<=0) break;
								}
							}
						}
					}
				}
			},
			kuangluan:{
				trigger:{player:'damageEnd'},
				forced:true,
				priority:10,
				filter(event,player){
					return event.source&&event.source.isIn()&&event.source!=player;
				},
				intro:{
					content:'players'
				},
				content(){
					trigger.source.goMad('phaseAfter');
					// if(!player.storage.kuangluan){
					// 	player.storage.kuangluan=[];
					// }
					// player.storage.kuangluan.add(trigger.source);
					// player.markSkill('kuangluan');
				},
				ai:{
					maixie_defend:true,
					threaten:0.3
				},
				// group:['kuangluan2','kuangluan3']
			},
			kuangluan2:{
				trigger:{player:'phaseBegin'},
				priority:10,
				forced:true,
				filter(event,player){
					return player.storage.kuangluan&&player.storage.kuangluan.length>=2;
				},
				content(){
					player.recover(player.maxHp);
					player.goMad('phaseAfter');
				}
			},
			kuangluan3:{
				trigger:{player:'phaseBegin'},
				silent:true,
				content(){
					player.storage.kuangluan=[];
					player.unmarkSkill('kuangluan');
				}
			},
			xiubu:{
				trigger:{player:'equipEnd'},
				frequent:true,
				filter(event){
					return lib.inpile.includes(event.card.name)&&get.subtype(event.card)=='equip1'&&typeof lib.cardType.hslingjian=='number';
				},
				content(){
					var num=1;
					var info=get.info(trigger.card);
					if(info&&info.distance&&typeof info.distance.attackFrom=='number'){
						num=1-info.distance.attackFrom;
					}
					if(num<1){
						num=1;
					}
					var list=get.typeCard('hslingjian');
					if(!list.length){
						return;
					}
					var cards=[];
					while(num--){
						cards.push(game.createCard(list.randomGet()));
					}
					player.gain(cards,'gain2');
				},
				threaten:1.3
			},
			zengli:{
				enable:'phaseUse',
				usable:1,
				filterTarget(card,player,target){
					return target!=player&&!target.isMin();
				},
				delay:false,
				content(){
					'step 0'
					var list=[];
					for(var i=0;i<lib.inpile.length;i++){
						if(lib.card[lib.inpile[i]].subtype=='equip1'){
							list.push(lib.inpile[i]);
						}
					}
					if(!list.length){
						event.finish();
						return;
					}
					event.card1=game.createCard(list.randomGet());
					event.card2=game.createCard(list.randomGet());
					player.$draw(event.card1);
					target.$draw(event.card2);
					game.delay();
					'step 1'
					player.equip(event.card1);
					'step 2'
					target.equip(event.card2);
				},
				ai:{
					order:11,
					result:{
						player:1,
						target(player,target){
							if(target.getEquip(1)) return 0;
							return 1;
						}
					}
				}
			},
			mobao:{
				enable:'phaseUse',
				usable:1,
				filter(event,player){
					if(!player.storage.mobao) return false;
					if(!player.countCards('h',{color:'black'})) return false;
					for(var i=0;i<player.storage.mobao.length;i++){
						if(player.storage.mobao[i].isAlive()) return true;
					}
					return false;
				},
				filterTarget(card,player,target){
					return player.storage.mobao.includes(target);
				},
				position:'he',
				selectTarget:-1,
				selectCard:[1,3],
				check(card){
					return 8-get.value(card);
				},
				filterCard:{color:'black'},
				line:'thunder',
				content(){
					target.damage('thunder',cards.length);
				},
				ai:{
					order:9,
					threaten:0.7,
					result:{
						target(player,target){
							return get.damageEffect(target,player,target,'thunder');
						}
					}
				},
				group:['mobao2','mobao3']
			},
			mobao2:{
				trigger:{player:'damageEnd'},
				silent:true,
				filter(event,player){
					return event.source&&event.source!=player;
				},
				content(){
					if(!player.storage.mobao){
						player.storage.mobao=[];
					}
					player.storage.mobao.add(trigger.source);
				},
				ai:{
					maixie_defend:true,
				}
			},
			mobao3:{
				trigger:{player:'phaseEnd'},
				silent:true,
				content(){
					delete player.storage.mobao;
				}
			},
			xianji:{
				unique:true,
				forceunique:true,
				global:'xianji2'
			},
			xianji2:{
				trigger:{player:'phaseEnd'},
				direct:true,
				filter(event,player){
					if(player.hasSkill('xianji')) return false;
					if(!player.countCards('he')) return false;
					if(player.hasSkill('xianji3')) return true;
					return game.hasPlayer(function(current){
						return current.hasSkill('xianji');
					});
				},
				content(){
					'step 0'
					player.removeSkill('xianji3');
					event.target=game.findPlayer(function(current){
						return current.hasSkill('xianji');
					});
					if(event.target){
						player.chooseToDiscard([1,2],'献祭：是否弃置1~2张手牌并令'+get.translation(event.target)+'摸等量的牌？').set('ai',function(card){
							if(get.attitude(_status.event.player,_status.event.getParent().target)>1){
								return 6-get.value(card);
							}
							return 0;
						}).set('logSkill',['xianji',event.target]);
					}
					else{
						event.finish();
					}
					'step 1'
					if(result.bool){
						event.target.draw(result.cards.length);
						player.storage.xianji3=event.target;
						player.addSkill('xianji3');
						player.addExpose(0.2);
					}
				}
			},
			xianji3:{
				mark:'character',
				intro:{
					content:'每当$对你使用一张牌，你摸一张牌'
				},
				trigger:{target:'useCardToBegin'},
				filter(event,player){
					return event.player==player.storage.xianji3;
				},
				forced:true,
				content(){
					player.draw();
				},
			},
			tanmi:{
				trigger:{global:'phaseEnd'},
				filter(event,player){
					return player.countCards('h')==0&&event.player!=player;
				},
				frequent:true,
				content(){
					'step 0'
					player.draw(2);
					'step 1'
					player.chooseToUse();
					'step 2'
					if(result.bool){
						player.chooseToUse();
					}
				},
				ai:{
					noh:true,
					skillTagFilter(player,tag){
						if(tag=='noh'){
							if(player.countCards('h')!=1) return false;
						}
					}
				}
			},
			xueren:{
				trigger:{source:'damageEnd'},
				filter(event){
					if(event._notrigger.includes(event.player)) return false;
					return event.card&&event.card.name=='sha'&&event.player.isAlive();
				},
				check(event,player){
					if(get.attitude(player,event.player)>=0) return false;
					if(player.hp>2) return true;
					if(player.hp<2) return false;
					return player.hp>=event.player.hp;
				},
				content(){
					'step 0'
					trigger.player.loseHp();
					'step 1'
					player.loseHp();
					'step 2'
					player.draw(2);
				}
			},
			maoxian:{
				enable:'phaseUse',
				usable:2,
				direct:true,
				delay:false,
				unique:true,
				content(){
					'step 0'
					var list=get.gainableSkills();
					list.remove('maoxian');
					list=list.randomGets(3);
					event.skillai=function(){
						return get.max(list,get.skillRank,'item');
					};
					if(event.isMine()){
						var dialog=ui.create.dialog('forcebutton');
						dialog.add('选择获得一项技能');
						var clickItem=function(){
							_status.event._result=this.link;
							dialog.close();
							game.resume();
						};
						for(var i=0;i<list.length;i++){
							if(lib.translate[list[i]+'_info']){
								var translation=get.translation(list[i]);
								if(translation[0]=='新'&&translation.length==3){
									translation=translation.slice(1,3);
								}
								else{
									translation=translation.slice(0,2);
								}
								var item=dialog.add('<div class="popup pointerdiv" style="width:80%;display:inline-block"><div class="skill">【'+
								translation+'】</div><div>'+lib.translate[list[i]+'_info']+'</div></div>');
								item.firstChild.addEventListener('click',clickItem);
								item.firstChild.link=list[i];
							}
						}
						dialog.add(ui.create.div('.placeholder'));
						event.switchToAuto=function(){
							event._result=event.skillai();
							dialog.close();
							game.resume();
						};
						_status.imchoosing=true;
						game.pause();
					}
					else{
						event._result=event.skillai();
					}
					'step 1'
					_status.imchoosing=false;
					var link=result;
					player.addAdditionalSkill('maoxian',link);
					player.popup(link);
					game.log(player,'获得了技能','【'+get.translation(link)+'】');
					player.checkMarks();
					player.markSkill('maoxian');
					game.delay();
				},
				intro:{
					content(storage,player){
						return '当前技能：'+get.translation(player.additionalSkills.maoxian);
					}
				},
				ai:{
					order:11,
					result:{
						player(player){
							if(player.getStat().skill.maoxian) return 0;
							return 1;
						}
					}
				}
			},
			maoxian_old:{
				enable:'phaseUse',
				usable:2,
				direct:true,
				delay:false,
				unique:true,
				getSkills(player,current){
					var names=[];
					var list=[];
					var map={};
					for(var i=0;i<game.players.length;i++){
						if(game.players[i]==player) continue;
						if(game.players[i].name&&lib.character[game.players[i].name]){
							names.add(game.players[i].name);
						}
						if(game.players[i].name1&&lib.character[game.players[i].name1]){
							names.add(game.players[i].name1);
						}
						if(game.players[i].name2&&lib.character[game.players[i].name2]){
							names.add(game.players[i].name2);
						}
					}
					for(var i=0;i<names.length;i++){
						var info=lib.character[names[i]];
						if(info){
							var skills=info[3];
							for(var j=0;j<skills.length;j++){
								if(skills[j]==current) continue;
								if(lib.translate[skills[j]+'_info']&&lib.skill[skills[j]]&&
									!lib.skill[skills[j]].unique){
									list.add(skills[j]);
									map[skills[j]]=names[i];
								}
							}
						}
					}
					return [list,map];
				},
				onremove(player){
					player.removeAdditionalSkill('maoxian');
				},
				content(){
					'step 0'
					var lm=lib.skill.maoxian.getSkills(player,player.additionalSkills.maoxian);
					var list=lm[0];
					event.map=lm[1];
					if(list.length){
						player.chooseControl(list.randomGets(3)).prompt='选择一项作为你的技能';
					}
					else{
						event.finish();
					}
					'step 1'
					if(result.control){
						game.stopCountChoose();
						var link=result.control;
						player.addSkill(link);
						player.skills.remove(link);
						if(player.additionalSkills.maoxian){
							player.removeSkill(player.additionalSkills.maoxian);
						}
						player.additionalSkills.maoxian=link;
						player.popup(link);
						game.log(player,'获得了技能','【'+get.translation(link)+'】')
						var name=event.map[link];
						var target;
						for(var i=0;i<game.players.length;i++){
							if(game.players[i]==player) continue;
							if(game.players[i].name==name||
							game.players[i].name1==name||
							game.players[i].name2==name){
								target=game.players[i];break;
							}
						}
						if(target&&(target.name==name||(target.name2==name&&!target.classList.contains('unseen2')))){
							player.line(target,'green');
							player.markSkillCharacter('maoxian',target,get.translation(link),lib.translate[link+'_info']);
						}
						player.checkMarks();
						game.delay();
					}
				},
				ai:{
					order:11,
					result:{
						player(player){
							if(player.getStat().skill.maoxian) return 0;
							return 1;
						}
					}
				}
			},
			yiwen:{
				trigger:{target:'useCardToBegin'},
				filter(event,player){
					return event.targets&&event.targets.length==1&&
					event.target!=event.player&&_status.currentPhase==event.player&&
					!event.player.hasSkill('yiwen2')&&!get.info(event.card).unique;
				},
				forced:true,
				content(){
					player.gain(game.createCard(trigger.card),'gain2');
					trigger.player.addTempSkill('yiwen2');
				},
				ai:{
					threaten:0.7
				}
			},
			yiwen2:{},
			tanbao_old:{
				enable:'phaseUse',
				usable:1,
				filter(event,player){
					if(player.hp==player.maxHp) return false;
					var hs=player.getCards('h');
					if(hs.length==0) return false;
					var types=[];
					for(var i=0;i<hs.length;i++){
						var type=get.type(hs[i],'trick');
						if(types.includes(type)){
							return false;
						}
						else{
							types.push(type);
						}
					}
					return true;
				},
				content(){
					'step 0'
					player.showHandcards();
					'step 1'
					player.recover(player.countCards('h'));
				},
				ai:{
					order:10,
					result:{
						player:1
					}
				}
			},
			tanbao_old2:{
				enable:'phaseUse',
				usable:10,
				filterCard:true,
				position:'he',
				check(card){
					if(_status.event.player.hp==1){
						return 7-get.value(card);
					}
					return 6-get.value(card);
				},
				selectCard:3,
				filter(event,player){
					return player.countCards('he')>=3;
				},
				content(){
					'step 0'
					event.cards=get.cards(3);
					if(!event.isMine()) player.showCards(event.cards);
					'step 1'
					player.chooseCardButton('获得任意张类别不同的牌',[1,3],event.cards).filterButton=function(button){
						var type=get.type(button.link,'trick');
						for(var i=0;i<ui.selected.buttons.length;i++){
							if(get.type(ui.selected.buttons[i].link,'trick')==type){
								return false;
							}
						}
						return true;
					}
					'step 2'
					if(result.bool) player.gain(result.links,'gain2');
					var types=[];
					for(var i=0;i<event.cards.length;i++){
						types.add(get.type(event.cards[i],'trick'));
					}
					if(types.length==3){
						player.recover(player.maxHp-player.hp);
					}
				},
				ai:{
					order:5,
					result:{
						player:1
					}
				}
			},
			qianghuax:{
				enable:'phaseUse',
				usable:1,
				filterCard(card){
					var type=get.type(card,'trick');
					for(var i=0;i<ui.selected.cards.length;i++){
						if(type==get.type(ui.selected.cards[i],'trick')) return false;
					}
					return true;
				},
				complexCard:true,
				position:'he',
				check(card){
					return 8-get.value(card);
				},
				selectCard:[1,Infinity],
				content(){
					var cards2=[];
					for(var i=0;i<cards.length;i++){
						var type=get.type(cards[i],'trick');
						var list=game.findCards(function(name){
							if(cards[i].name==name) return;
							if(get.type({name:name},'trick')==type){
								return get.value({name:name})>get.value(cards[i]);
							}
						});
						if(!list.length){
							list=game.findCards(function(name){
								if(cards[i].name==name) return;
								if(get.type({name:name},'trick')==type){
									return get.value({name:name})==get.value(cards[i]);
								}
							});
						}
						if(!list.length){
							list=[cards[i].name];
						}
						cards2.push(game.createCard(list.randomGet()));
					}
					player.gain(cards2,'log');
					player.$draw(cards2);
				},
				ai:{
					order:8,
					result:{
						player:1
					}
				}
			},
			zhuizong:{
				enable:'phaseUse',
				usable:1,
				filterCard:true,
				position:'he',
				selectCard:[1,Infinity],
				check(card){
					if(ui.selected.cards.length) return 0;
					return 6-get.value(card)
				},
				content(){
					'step 0'
					event.cards=get.cards(4*cards.length);
					player.chooseCardButton('获得其中的一张牌',true,event.cards,true);
					'step 1'
					player.gain(result.links,'draw');
					event.cards.remove(result.links[0]);
					for(var i=0;i<event.cards.length;i++){
						event.cards[i].discard();
					}
				},
				ai:{
					order:8,
					result:{
						player:1
					},
				}
			},
			xunbao:{
				trigger:{player:'phaseBegin'},
				frequent:true,
				filter(event,player){
					return !player.hasSkill('xunbao2');
				},
				derivation:['hsbaowu_cangbaotu','hsbaowu_huangjinyuanhou'],
				priority:1,
				// filterCard:true,
				// check(card){
				// 	return 6-get.value(card);
				// },
				// position:'he',
				content(){
					'step 0'
					event.card=game.createCard('hsbaowu_cangbaotu');
					player.storage.xunbao2=event.card;
					player.storage.xunbao2_markcount=player.storage.xunbao2.number;
					// player.$draw(player.storage.xunbao2);
					player.addSkill('xunbao2');
					game.delay(2);
					event.node=event.card.copy('thrown','center','thrownhighlight',ui.arena).addTempClass('start');
					ui.arena.classList.add('thrownhighlight');
					game.addVideo('thrownhighlight1');
					game.addVideo('centernode',null,get.cardInfo(event.card));
					'step 1'
					game.addVideo('deletenode',player,[get.cardInfo(event.node)]);
					event.node.delete();
					event.node.style.transform='scale(0)';
					game.addVideo('thrownhighlight2');
					ui.arena.classList.remove('thrownhighlight');
				},
				ai:{
					order:3,
					result:{
						player:1
					}
				}
			},
			xunbao2:{
				mark:true,
				marktext:'宝',
				intro:{
					content:'card',
				},
				direct:true,
				trigger:{player:'phaseBegin'},
				filter(event,player){
					var hs=player.getCards('he');
					for(var i=0;i<hs.length;i++){
						if(hs[i].number==player.storage.xunbao2.number) return true;
					}
					return false;
				},
				content(){
					'step 0'
					player.chooseToDiscard('是否弃置一张点数为'+player.storage.xunbao2.number+'的牌获得藏宝图？','he',function(card){
						return card.number==player.storage.xunbao2.number;
					}).ai=function(card){
						return 7-get.value(card);
					};
					'step 1'
					if(result.bool){
						player.gain(player.storage.xunbao2,'gain2','log');
						delete player.storage.xunbao2;
						player.removeSkill('xunbao2');
					}
				}
			},
			hsbaowu_cangbaotu:{
				trigger:{player:'phaseEnd'},
				forced:true,
				popup:false,
				content(){
					player.gain(game.createCard('hsbaowu_huangjinyuanhou'),'gain2');
					player.removeSkill('hsbaowu_cangbaotu');
				}
			},
			hsbaowu_huangjinyuanhou:{
				mark:'card',
				nopup:true,
				intro:{
					content:'锁定技，你不能成为其他角色的卡牌的目标'
				},
				mod:{
					targetEnabled(card,player,target){
						if(player!=target) return false;
					}
				},
				group:'hsbaowu_huangjinyuanhou2'
			},
			hsbaowu_huangjinyuanhou2:{
				trigger:{player:'phaseBegin'},
				silent:true,
				content(){
					player.removeSkill('hsbaowu_huangjinyuanhou');
					delete player.storage.hsbaowu_huangjinyuanhou;
				}
			},
			xieneng:{
				trigger:{player:'phaseEnd'},
				direct:true,
				content(){
					'step 0'
					var list=[['','','hsshenqi_morijingxiang'],
						['','','hsshenqi_kongbusangzhong'],
						['','','hsshenqi_nengliangzhiguang']];
					var dialog=ui.create.dialog(get.prompt('xieneng'),[list,'vcard'],'hidden');
					player.chooseButton(dialog).ai=function(){return Math.random();};
					'step 1'
					if(result.buttons){
						player.logSkill('xieneng');
						player.gain(game.createCard(result.buttons[0].link[2]),'draw');
					}
				},
				ai:{
					threaten:1.3,
					effect:{
						target(card,player,target){
							if(card.name=='guiyoujie') return [0,1];
						}
					}
				}
			},
			fbeifa:{
				trigger:{player:'loseEnd'},
				filter(event,player){
					if(player.countCards('h')) return false;
					for(var i=0;i<event.cards.length;i++){
						if(event.cards[i].original=='h') return true;
					}
					return false;
				},
				direct:true,
				usable:3,
				content(){
					"step 0"
					player.chooseTarget(get.prompt('fbeifa'),function(card,player,target){
						return lib.filter.targetEnabled({name:'sha'},player,target);
					}).ai=function(target){
						return get.effect(target,{name:'sha'},player);
					}
					"step 1"
					if(result.bool){
						player.logSkill('fbeifa');
						player.useCard({name:'sha'},result.targets,false);
					}
				},
				ai:{
					noh:true,
					skillTagFilter(player,tag){
						if(tag=='noh'){
							if(player.countCards('h')!=1) return false;
						}
					},
					expose:0.2,
				},
				group:['fbeifa_draw'],
				subSkill:{
					draw:{
						trigger:{source:'damageAfter'},
						forced:true,
						popup:false,
						filter(event){
							return event.parent.parent.parent.name=='fbeifa';
						},
						content(){
							player.draw();
						}
					}
				}
			},
			oldfbeifa:{
				trigger:{player:'loseEnd'},
				filter(event,player){
					if(player.countCards('h')) return false;
					for(var i=0;i<event.cards.length;i++){
						if(event.cards[i].original=='h') return true;
					}
					return false;
				},
				direct:true,
				usable:3,
				content(){
					"step 0"
					player.chooseTarget(get.prompt('fbeifa'),function(card,player,target){
						return lib.filter.targetEnabled({name:'sha'},player,target);
					}).ai=function(target){
						return get.effect(target,{name:'sha'},player);
					}
					"step 1"
					if(result.bool){
						player.logSkill('fbeifa');
						player.useCard({name:'sha'},result.targets,false);
					}
				},
				ai:{
					expose:0.2,
				},
				group:['oldfbeifa_draw'],
				subSkill:{
					draw:{
						trigger:{source:'damageAfter'},
						forced:true,
						popup:false,
						filter(event){
							return event.parent.parent.parent.name=='oldfbeifa';
						},
						content(){
							player.draw();
						}
					}
				}
			},
			yufa:{
				trigger:{global:'phaseEnd'},
				direct:true,
				filter(event,player){
					return player.storage.yufa==event.player;
				},
				content(){
					'step 0'
					player.chooseTarget(get.prompt('yufa'),function(card,player,target){
						return target!=trigger.player;
					}).ai=function(target){
						return get.attitude(player,target);
					};
					'step 1'
					if(result.bool){
						player.logSkill('yufa',result.targets);
						result.targets[0].gain(game.createCard('chuansongmen'),'gain2');
					}
				},
				group:['yufa2','yufa3'],
				ai:{
					maixie:true,
					maixie_hp:true,
					expose:0.1
				}
			},
			yufa2:{
				trigger:{player:'damageEnd'},
				filter(event,player){
					return event.source==_status.currentPhase&&event.source!=player;
				},
				silent:true,
				content(){
					player.storage.yufa=trigger.source;
				}
			},
			yufa3:{
				trigger:{global:'phaseBegin'},
				silent:true,
				content(){
					player.storage.yufa=null;
				}
			},
			bingyan:{
				enable:'phaseUse',
				usable:1,
				filter(event,player){
					if(!lib.card.chiyuxi||!lib.card.jingleishan) return false;
					return player.countCards('he')>0;
				},
				filterTarget(card,player,target){
					if(get.color(card)=='red'){
						return player.canUse('chiyuxi',target);
					}
					else{
						return player.canUse('jingleishan',target);
					}
				},
				selectTarget:-1,
				discard:false,
				delay:false,
				line:false,
				filterCard:true,
				position:'he',
				log:'notarget',
				check(card){
					return 6-get.value(card);
				},
				multitarget:true,
				content(){
					if(get.color(cards[0])=='black'){
						player.useCard({name:'jingleishan'},cards,targets);
					}
					else{
						player.useCard({name:'chiyuxi'},cards,targets);
					}
				},
				ai:{
					order:9.1,
					result:{
						target(player,target){
							var card=ui.selected.cards[0];
							if(card&&get.color(card)=='black'){
								return get.effect(target,{name:'jingleishan'},player,target);
							}
							return get.effect(target,{name:'chiyuxi'},player,target);
						}
					}
				}
			},
			shifa:{
				trigger:{player:'phaseUseBegin'},
				forced:true,
				content(){
					'step 0'
					var list=[];
					var target=player.getEnemies().randomGet();
					for(var i=0;i<lib.inpile.length;i++){
						if(lib.card[lib.inpile[i]].type=='trick'){
							list.push(lib.inpile[i]);
						}
					}
					player.gain(game.createCard(list.randomGet()));
					player.$draw();
					if(target){
						target.gain(game.createCard(list.randomGet()));
						target.$draw();
						target.addExpose(0.2);
						player.line(target,'green');
						game.log(player,'和',target,'获得了一张锦囊牌');
					}
					'step 1'
					game.delay();
				},
				group:'shifa_draw',
				subSkill:{
					draw:{
						trigger:{player:'useCard'},
						frequent:true,
						usable:3,
						filter(event,player){
							if(_status.currentPhase!=player) return false;
							return (get.type(event.card)=='trick'&&event.card.isCard);
						},
						content(){
							player.draw();
						}
					}
				},
				ai:{
					threaten:1.5,
					noautowuxie:true,
				}
			},
			oldshifa:{
				trigger:{player:'phaseUseBegin'},
				forced:true,
				content(){
					'step 0'
					var list=[];
					var target=player.getEnemies().randomGet();
					for(var i=0;i<lib.inpile.length;i++){
						if(lib.card[lib.inpile[i]].type=='trick'){
							list.push(lib.inpile[i]);
						}
					}
					player.gain(game.createCard(list.randomGet()));
					player.$draw();
					if(target){
						target.gain(game.createCard(list.randomGet()));
						target.$draw();
						target.addExpose(0.2);
						player.line(target,'green');
						game.log(player,'和',target,'获得了一张锦囊牌');
					}
					'step 1'
					game.delay();
				},
				group:'oldshifa_draw',
				subSkill:{
					draw:{
						trigger:{player:'useCard'},
						frequent:true,
						filter(event,player){
							if(_status.currentPhase!=player) return false;
							return (get.type(event.card)=='trick'&&event.card.isCard);
						},
						content(){
							player.draw();
						}
					}
				},
				ai:{
					threaten:1.5,
					noautowuxie:true,
				}
			},
			yuanzheng:{
				trigger:{player:'useCardToBegin'},
				direct:true,
				filter(event,player){
					return event.target&&event.target!=player&&get.distance(player,event.target)>1&&event.target.countCards('he')>0;
				},
				content(){
					player.discardPlayerCard(trigger.target,get.prompt('yuanzheng',trigger.target),'hej').logSkill=['yuanzheng',trigger.target];
				}
			},
			yuanzheng_old:{
				trigger:{player:'useCardToBegin'},
				direct:true,
				filter(event,player){
					if(event.getParent(2).name=='yuanzheng') return false;
					return event.target&&event.target!=player&&get.distance(player,event.target,'attack')>1;
				},
				content(){
					'step 0'
					player.chooseControl('draw_card','出杀','cancel2',function(){
						if(get.effect(trigger.target,{name:'sha'},player,player)>0){
							return '出杀';
						}
						return 'draw_card';
					}).prompt='是对'+get.translation(trigger.target)+'发动否发动【远征】？';
					'step 1'
					if(result.control!='cancel2'){
						if(result.control=='draw_card'){
							player.draw();
							player.logSkill('yuanzheng');
						}
						else{
							player.logSkill('yuanzheng',trigger.target);
							player.useCard({name:'sha'},trigger.target,false).animate=false;
							// player.discardPlayerCard(trigger.target,'he',true);
						}
					}
				}
			},
			byuhuo:{
				unique:true,
				trigger:{player:'dying'},
				priority:6,
				forced:true,
				mark:true,
				skillAnimation:true,
				animationColor:'fire',
				init(player){
					player.storage.byuhuo=false;
				},
				filter(event,player){
					if(player.hp>0) return false;
					if(player.storage.byuhuo) return false;
					return true;
				},
				content(){
					player.storage.byuhuo=true;
					player.addSkill('byuhuo2');
					player.maxHp=2;
					player.hp=2;
					player.update();
					if(!player.isTurnedOver()){
						player.turnOver();
					}
				},
				ai:{
					threaten(player,target){
						if(!target.storage.byuhuo) return 0.6;
					}
				},
				intro:{
					content(storage,player){
						if(storage){
							if(player.hasSkill('byuhuo2')){
								return '不能成为其他角色卡牌的目标；在下一准备阶段，对所有其他角色造成2点火焰伤害';
							}
							return '已发动';
						}
						else{
							return '未发动';
						}
					}
				}
			},
			byuhuo2:{
				trigger:{player:'phaseBegin'},
				forced:true,
				content(){
					'step 0'
					var targets=game.filterPlayer();
					targets.remove(player);
					targets.sort(lib.sort.seat);
					event.targets=targets;
					event.num=0;
					player.unmarkSkill('byuhuo');
					'step 1'
					if(num<event.targets.length){
						// if(event.targets[num].countCards('hej')){
						// 	player.gainPlayerCard(event.targets[num],'hej',true);
						// }
						player.line(event.targets[num],'fire');
						event.targets[num].damage(2,'fire');
						event.num++;
						event.redo();
					}
				},
				mod:{
					targetEnabled(card,player,target){
						if(player!=target) return false;
					}
				}
			},
			yulu:{
				enable:'phaseUse',
				usable:1,
				filterTarget:true,
				selectTarget:[1,Infinity],
				content(){
					'step 0'
					if(target==targets[0]){
						game.asyncDraw(targets);
					}
					'step 1'
					if(target==targets[0]){
						game.delay();
					}
					'step 2'
					target.chooseToDiscard('hej',true);
				},
				ai:{
					order:10,
					result:{
						target(player,target){
							if(target.countCards('j')) return 2;
							switch(target.countCards('he')){
								case 0:return 0;
								case 1:return 0.5;
								case 2:return 0.8;
								default:return 1;
							}
						}
					},
					threaten:1.2
				}
			},
			oldyulu:{
				enable:'phaseUse',
				usable:1,
				filterTarget:true,
				selectTarget:[1,Infinity],
				content(){
					'step 0'
					if(target==targets[0]){
						game.asyncDraw(targets,2);
					}
					'step 1'
					if(target==targets[0]){
						game.delay();
					}
					'step 2'
					target.chooseToDiscard('hej',2,true);
				},
				ai:{
					order:10,
					result:{
						target(player,target){
							if(target.countCards('j')) return 2;
							switch(target.countCards('he')){
								case 0:return 0;
								case 1:return 0.5;
								case 2:return 0.8;
								default:return 1;
							}
						}
					},
					threaten:1.2
				}
			},
			duzhang:{
				trigger:{player:'phaseEnd'},
				direct:true,
				filter(event,player){
					var stat=player.getStat('card');
					for(var i in stat){
						if(typeof stat[i]=='number'&&get.type(i,'trick')=='trick'){
							return false;
						}
					}
					return true;
				},
				content(){
					'step 0'
					player.chooseTarget(get.prompt('duzhang'),function(card,player,target){
						return target!=player;
					}).ai=function(target){
						return -get.attitude(player,target)*Math.sqrt(target.countCards('h'));
					}
					'step 1'
					if(result.bool){
						player.logSkill('duzhang',result.targets);
						result.targets[0].addTempSkill('duzhang2',{player:'phaseAfter'});
					}
				}
			},
			duzhang2:{
				mod:{
					cardEnabled(card){
						if(get.type(card,'trick')=='trick') return false;
					}
				},
				mark:true,
				marktext:'瘴',
				intro:{
					content:'下个回合无法使用锦囊牌'
				}
			},
			hannu:{
				trigger:{player:'damageEnd'},
				forced:true,
				filter(event,player){
					return player.countCards('h')>0;
				},
				content(){
					'step 0'
					var nh=player.countCards('h');
					if(nh){
						player.draw(nh);
					}
					else{
						event.finish();
					}
					'step 1'
					var hs=player.getCards('h');
					if(hs.length>10&&hs.length>player.hp){
						player.discard(hs.randomGets(hs.length-player.hp));
					}
				},
				ai:{
					maixie:true,
					maixie_hp:true,
					effect:{
						target(card,player,target){
							if(get.tag(card,'damage')){
								if(player.hasSkillTag('jueqing',false,target)) return [1,-2];
								if(!target.hasFriend()) return;
								var nh=target.countCards('h');
								if(nh>5) return [1,-1];
								if(nh<=1) return [1,-0.1];
								if(nh==2){
									if(target.hp>=2) return [1,0.1];
								}
								else{
									if(target.hp>=4) return [1,2];
									if(target.hp==3) return [1,1.5];
									if(target.hp==2) return [1,0.5];
								}
							}
						}
					}
				}
			},
			chuidiao:{
				trigger:{player:'phaseEnd'},
				forced:true,
				content(){
					var num=Math.floor(Math.random()*3);
					if(num) player.draw(num);
				},
			},
			hhudun:{
				trigger:{global:'phaseBegin'},
				forced:true,
				filter(event,player){
					return !player.hujia;
				},
				content(){
					player.changeHujia();
				},
				group:'hhudun_hujia',
				subSkill:{
					hujia:{
						trigger:{player:'damageEnd'},
						filter(event){
							return event.hujia==event.num;
						},
						forced:true,
						content(){
							player.draw();
						}
					}
				},
				ai:{
					threaten(player,target){
						if(target.hujia){
							return 0.5;
						}
						else{
							return 2;
						}
					}
				}
			},
			fenlie:{
				audio:2,
				forced:true,
				trigger:{player:'gainAfter'},
				filter(event,player){
					if(event.parent.parent.name=='phaseDraw') return false;
					if(event.parent.name=='fenlie') return false;
					if(!event.cards) return false;
					for(var i=0;i<event.cards.length;i++){
						if(!get.info(event.cards[i]).unique) return true;
					}
					return false;
				},
				usable:2,
				content(){
					var cards=[];
					for(var i=0;i<trigger.cards.length;i++){
						if(get.info(trigger.cards[i]).unique) continue;
						cards.push(game.createCard(trigger.cards[i]));
					}
					player.gain(cards,'draw');
				},
				ai:{
					effect:{
						target(card){
							if(card.name=='toulianghuanzhu'){
								return [1,2];
							}
						}
					}
				}
			},
			oldfenlie:{
				audio:2,
				forced:true,
				trigger:{player:'gainAfter'},
				filter(event,player){
					if(event.parent.parent.name=='phaseDraw') return false;
					if(event.parent.name=='oldfenlie') return false;
					if(!event.cards) return false;
					for(var i=0;i<event.cards.length;i++){
						if(!get.info(event.cards[i]).unique) return true;
					}
					return false;
				},
				content(){
					var cards=[];
					for(var i=0;i<trigger.cards.length;i++){
						if(get.info(trigger.cards[i]).unique) continue;
						cards.push(game.createCard(trigger.cards[i]));
					}
					player.gain(cards,'draw');
				},
				ai:{
					effect:{
						target(card){
							if(card.name=='toulianghuanzhu'){
								return [1,2];
							}
						}
					}
				}
			},
			nianfu:{
				trigger:{source:'damageEnd',player:'damageEnd'},
				forced:true,
				filter(event,player){
					if(event._notrigger.includes(event.player)) return false;
					if(player==event.source){
						return event.player!=player&&event.player.countCards('e')>0;
					}
					else{
						return event.source&&event.source!=player&&event.source.countCards('e')>0;
					}
				},
				logTarget(event,player){
					if(player==event.player){
						return event.source;
					}
					else{
						return event.player;
					}
				},
				content(){
					var target=(player==trigger.player)?trigger.source:trigger.player;
					if(target){
						var cards=target.getCards('e');
						if(cards.length){
							var card=cards.randomGet();
							player.gain(card,target);
							target.$give(card,player);
						}
					}
				},
			},
			xiaorong:{
				mod:{
					ignoredHandcard(card,player){
						if(get.type(card)=='equip'){
							return true;
						}
					},
				},
				trigger:{player:'phaseEnd'},
				forced:true,
				filter(event,player){
					return player.countCards('h',{type:'equip'})>0;
				},
				content(){
					var cards=player.getCards('h',{type:'equip'});
					if(cards.length){
						player.lose(cards)._triggered=null;
						var list=[];
						var names=[];
						for(var i=0;i<lib.inpile.length;i++){
							if(lib.card[lib.inpile[i]].type=='basic'){
								names.push(lib.inpile[i]);
							}
						}
						names.remove('du');
						for(var i=0;i<cards.length*2;i++){
							list.push(game.createCard(names.randomGet()));
						}
						player.directgain(list);
						player.recover(cards.length);
					}
				},
				ai:{
					effect:{
						player(card,player){
							if(_status.currentPhase!=player) return;
							if(get.type(card)=='equip'&&get.equipValueNumber(card)<7){
								if(player.needsToDiscard(2)) return;
								return [0,0,0,0];
							}
						}
					},
				}
			},
			shixu:{
				group:['shixu_begin','shixu_end','shixu_discard'],
				subSkill:{
					begin:{
						trigger:{global:'phaseUseBegin'},
						silent:true,
						content(){
							trigger.player.storage.shixu_begin=get.time();
						}
					},
					end:{
						trigger:{global:'phaseUseEnd'},
						silent:true,
						filter(event,player){
							return typeof event.player.storage.shixu_begin=='number';
						},
						content(){
							trigger.player.storage.shixu=get.time()-trigger.player.storage.shixu_begin;
							delete trigger.player.storage.shixu_begin;
						}
					},
					discard:{
						trigger:{global:'phaseEnd'},
						forced:true,
						check(event,player){
							return get.attitude(player,event.player)<0;
						},
						filter(event,player){
							return typeof event.player.storage.shixu=='number'&&
								event.player.storage.shixu>3000&&event.player.countCards('he')>0&&event.player.isAlive();
						},
						content(){
							player.line(trigger.player,'green');
							trigger.player.chooseToDiscard('he',true,Math.floor(trigger.player.storage.shixu/3000));
							delete trigger.player.storage.shixu;
						}
					}
				}
			},
			jixuan:{
				trigger:{player:'phaseAfter'},
				forced:true,
				priority:-50,
				filter(event,player){
					return event.skill!='jixuan';
				},
				content(){
					player.draw();
					player.insertPhase();
				},
				ai:{
					threaten:1.8
				},
			},
			qianghua:{
				trigger:{player:'useCardAfter'},
				filter(event,player){
					if(event.parent.name=='qianghua') return false;
					if(player.storage.qianghua>=1) return false;
					if(_status.currentPhase!=player) return false;
					if(event.parent.parent.name!='phaseUse') return false;
					if(!event.targets||!event.card) return false;
					if(get.info(event.card).complexTarget) return false;
					if(!lib.filter.cardEnabled(event.card,player,event.parent)) return false;
					var type=get.type(event.card);
					if(type!='basic'&&type!='trick') return false;
					var card=game.createCard(event.card.name,event.card.suit,event.card.number,event.card.nature);
					var targets=event._targets||event.targets;
					for(var i=0;i<targets.length;i++){
						if(!targets[i].isIn()) return false;
						if(!player.canUse({name:event.card.name},targets[i],false,false)){
							return false;
						}
					}
					return true;
				},
				check(event,player){
					if(get.tag({name:event.card.name},'norepeat')) return false;
					return true;
				},
				content(){
					player.storage.qianghua++;
					var card=game.createCard(trigger.card.name,trigger.card.suit,trigger.card.number,trigger.card.nature);
					player.useCard(card,(trigger._targets||trigger.targets).slice(0));
				},
				ai:{
					threaten:1.3
				},
				group:'qianghua_clear',
				subSkill:{
					clear:{
						trigger:{player:'phaseBefore'},
						silent:true,
						content(){
							player.storage.qianghua=0;
						}
					}
				}
			},
			qianghua2:{},
			biri:{
				trigger:{global:'useCard'},
				priority:15,
				filter(event,player){
					return event.card.name=='sha'&&event.player!=player&&
						get.distance(player,event.targets[0])<=1&&
						player.countCards('h','shan')>0&&
						event.targets.includes(player)==false&&event.targets.length==1;
				},
				direct:true,
				content(){
					"step 0"
					var effect=0;
					for(var i=0;i<trigger.targets.length;i++){
						effect+=get.effect(trigger.targets[i],trigger.card,trigger.player,player);
					}
					var str='蔽日：是否弃置一张闪令'+get.translation(trigger.player);
					if(trigger.targets&&trigger.targets.length){
						str+='对'+get.translation(trigger.targets);
					}
					str+='的'+get.translation(trigger.card)+'失效？';
					var next=player.chooseToDiscard('h',function(card){
						return card.name=='shan';
					},str);
					next.ai=function(card){
						if(effect<0){
							return 9-get.value(card);
						}
						return -1;
					}
					next.autodelay=true;
					next.logSkill=['biri',trigger.targets];
					"step 1"
					if(result.bool){
						trigger.cancel();
					}
				},
				ai:{
					expose:0.2
				}
			},
			stuxi:{
				trigger:{player:'phaseEnd'},
				forced:true,
				filter(event,player){
					var enemies=player.getEnemies();
					for(var i=0;i<enemies.length;i++){
						if(!enemies[i].hasSkill('stuxi2')) return true;
					}
					return false;
				},
				content(){
					var enemies=player.getEnemies();
					for(var i=0;i<enemies.length;i++){
						if(enemies[i].hasSkill('stuxi2')){
							enemies.splice(i--,1);
						}
					}
					var target=enemies.randomGet();
					if(target){
						player.line(target,'green');
						target.addExpose(0.2);
						target.addSkill('stuxi2');
					}
				},
				ai:{
					expose:0.2
				}
			},
			stuxi2:{
				trigger:{player:'phaseDrawBegin'},
				forced:true,
				mark:true,
				intro:{
					content:'下个摸牌阶段摸牌数-1'
				},
				filter(event){
					return event.num>0;
				},
				content(){
					trigger.num--;
					player.removeSkill('stuxi2');
				}
			},
			bingdong:{
				trigger:{source:'damageEnd'},
				forced:true,
				usable:1,
				filter(event,player){
					if(!lib.card.hslingjian_jinjilengdong){
						return false;
					}
					return true;
				},
				content(){
					player.gain(game.createCard('hslingjian_jinjilengdong'),'gain2');
				}
			},
			bingdong_old:{
				enable:'phaseUse',
				usable:1,
				filter(event,player){
					return !player.isTurnedOver();
				},
				filterTarget(card,player,target){
					return !target.isTurnedOver()&&player!=target;
				},
				content(){
					'step 0'
					if(!player.isTurnedOver()){
						player.turnOver();
					}
					'step 1'
					if(!target.isTurnedOver()){
						target.turnOver();
					}
				},
				ai:{
					order:1,
					expose:0.2,
					result:{
						target(player,target){
							if(get.attitude(player,target)<-3&&player.identity!='zhu'){
								return -1;
							}
							return 0;
						}
					}
				}
			},
			luoshi:{
				trigger:{player:'damageEnd'},
				forced:true,
				filter(event,player){
					return player.countCards('he')>0||(event.source&&event.source.countCards('he')>0);
				},
				content(){
					'step 0'
					var hs=player.getCards('he');
					if(hs.length){
						player.discard(hs.randomGet())
					}
					'step 1'
					if(trigger.source){
						var hs=trigger.source.getCards('he');
						if(hs.length){
							trigger.source.discard(hs.randomGet())
						}
					}
				},
				ai:{
					maixie_defend:true,
				}
			},
			ronghuo:{
				trigger:{player:'useCardToBefore'},
				priority:7,
				filter(event,player){
					if(event.card.name=='sha'&&!event.card.nature) return true;
				},
				check(event,player){
					var att=get.attitude(player,event.target);
					if(event.target.hasSkillTag('nofire')){
						return att>0;
					}
					return att<=0;
				},
				forced:true,
				content(){
					trigger.card.nature='fire';
					player.addSkill('ronghuo2');
					player.storage.ronghuo=trigger.card;
				}
			},
			ronghuo2:{
				trigger:{player:'useCardAfter'},
				forced:true,
				popup:false,
				content(){
					delete player.storage.ronghuo.nature;
				}
			},
			fushi:{
				enable:'phaseUse',
				usable:1,
				filterTarget(card,player,target){
					return target.hp<target.maxHp;
				},
				content(){
					'step 0'
					target.loseMaxHp(true);
					'step 1'
					if(target.hp<target.maxHp){
						target.recover();
					}
				},
				ai:{
					threaten:1.4,
					expose:0.2,
					order:9,
					result:{
						target(player,target){
							if(target.hp==target.maxHp) return 0;
							if(target.hp==target.maxHp-1) return -1;
							if(target.hp==1) return 1;
							if(target.hp<target.maxHp-2) return 0.5;
							return 0;
						}
					}
				}
			},
			oldfushi:{
				enable:'phaseUse',
				filterTarget(card,player,target){
					return target.hp<target.maxHp;
				},
				content(){
					'step 0'
					target.loseMaxHp(true);
					'step 1'
					if(target.hp<target.maxHp){
						target.recover();
					}
				},
				ai:{
					threaten:1.4,
					expose:0.2,
					order:9,
					result:{
						target(player,target){
							if(target.hp==target.maxHp) return 0;
							if(target.hp==target.maxHp-1) return -1;
							if(target.hp==1) return 1;
							if(target.hp<target.maxHp-2) return 0.5;
							return 0;
						}
					}
				}
			},
			moyao:{
				mod:{
					targetEnabled(card,player,target,now){
						if(player!=target){
							if(get.type(card,'trick')=='trick') return false;
						}
					}
				}
			},
			jiaohui:{
				trigger:{player:'phaseEnd'},
				direct:true,
				filter(event,player){
					return !player.getStat('damage');
				},
				content(){
					'step 0'
					player.chooseTarget(get.prompt('jiaohui')).ai=function(target){
						var att=get.attitude(player,target);
						if(att>1){
							if(target.hp<=1) att+=2;
							if(target.hp<=2) att++;
						}
						return att;
					};
					'step 1'
					if(result.bool){
						event.target=result.targets[0];
						player.logSkill('jiaohui',event.target);
						event.target.chooseDrawRecover(true);
					}
				},
			},
			bimeng:{
				trigger:{player:'phaseEnd'},
				frequent:true,
				content(){
					var list=['hsmengjing_feicuiyoulong','hsmengjing_huanxiaojiemei',
						'hsmengjing_suxing','hsmengjing_mengye','hsmengjing_mengjing'];
					player.gain(game.createCard(list.randomGet()));
					player.$draw();
				},
				ai:{
					threaten:2
				}
			},
			zhoujiang:{
				trigger:{player:'useCard'},
				forced:true,
				filter(event,player){
					return get.type(event.card)=='trick';
				},
				content(){
					var list=['hszuzhou_nvwudeganguo','hszuzhou_nvwudepingguo',
						'hszuzhou_nvwudexuetu','hszuzhou_wushushike','hszuzhou_guhuo'];
					player.gain(game.createCard(list.randomGet()),'draw');
				},
				ai:{
					threaten:1.5
				}
			},
			liehun:{
				trigger:{player:'phaseEnd'},
				forced:true,
				filter(event,player){
					return player.hasCard(function(card){
						return get.type(card)!='basic'&&!get.info(card).unique;
					});
				},
				content(){
					var hs=player.getCards('h');
					for(var i=0;i<hs.length;i++){
						if(get.type(hs[i])=='basic'||get.info(hs[i]).unique){
							hs.splice(i--,1);
						}
					}
					if(hs.length){
						var hs2=[];
						for(var i=0;i<hs.length;i++){
							hs2.push(game.createCard(hs[i].name,hs[i].suit,hs[i].number));
						}
						player.gain(hs2,'draw');
					}
				},
				ai:{
					threaten:1.5
				}
			},
			xjumo:{
				mod:{
					maxHandcard(player,num){
						if(player.hp<player.maxHp) return num+5;
						return num+3;
					},
				},
			},
			malymowang:{
				trigger:{source:'damageBegin'},
				forced:true,
				usable:1,
				filter(event){
					return event.card&&get.type(event.card)=='trick'&&event.parent.name!='_lianhuan'&&event.parent.name!='_lianhuan2';
				},
				content(){
					trigger.num++;
				},
				group:'malymowang_discover',
				ai:{
					threaten:1.8
				},
				subSkill:{
					discover:{
						trigger:{player:'phaseUseBegin'},
						forced:true,
						content(){
							player.discoverCard(get.inpile('trick'));
						}
					}
				}
			},
			oldmalymowang:{
				trigger:{source:'damageBegin'},
				forced:true,
				filter(event){
					return event.card&&get.type(event.card)=='trick'&&event.parent.name!='_lianhuan'&&event.parent.name!='_lianhuan2';
				},
				content(){
					trigger.num++;
				},
				group:'oldmalymowang_discover',
				ai:{
					threaten:1.8
				},
				subSkill:{
					discover:{
						trigger:{player:'phaseUseBegin'},
						forced:true,
						content(){
							player.discoverCard(get.inpile('trick'));
						}
					}
				}
			},
			lingzhou:{
				trigger:{player:'useCard'},
				direct:true,
				filter(event){
					return get.type(event.card,'trick')=='trick'&&event.card.isCard;
				},
				content(){
					"step 0"
					player.chooseTarget(get.prompt('lingzhou')).ai=function(target){
						var num=get.attitude(player,target);
						if(num>0){
							if(target==player){
								num++;
							}
							if(target.hp==1){
								num+=3;
							}
							else if(target.hp==2){
								num+=1;
							}
						}
						return num;
					}
					"step 1"
					if(result.bool){
						player.logSkill('lingzhou',result.targets);
						result.targets[0].chooseDrawRecover(true);
					}
				},
				ai:{
					expose:0.2,
					threaten:1.5,
					noautowuxie:true,
				}
			},
			mieshi:{
				trigger:{player:'phaseEnd'},
				forced:true,
				content(){
					'step 0'
					player.loseHp();
					'step 1'
					event.target=game.filterPlayer().randomGet(player);
					if(!event.target){
						event.finish();
						return;
					}
					player.line(event.target,'fire');
					game.delayx();
					'step 2'
					event.target.damage('fire');
				}
			},
			xmojian:{
				trigger:{player:'turnOverAfter'},
				direct:true,
				filter(event,player){
					return !player.isTurnedOver();
				},
				content(){
					"step 0"
					player.chooseTarget(get.prompt('xmojian'),function(card,player,target){
						return lib.filter.targetEnabled({name:'sha'},player,target);
					}).ai=function(target){
						return get.effect(target,{name:'sha'},player);
					}
					"step 1"
					if(result.bool){
						player.logSkill('xmojian');
						player.useCard({name:'sha'},result.targets,false);
					}
				},
				ai:{
					expose:0.2,
				}
			},
			xshixin:{
				trigger:{source:'damageEnd'},
				forced:true,
				// alter:true,
				filter(event,player){
					if(event._notrigger.includes(event.player)) return false;
					if(get.is.altered('xshixin')&&event.player.hp<player.hp) return false;
					return event.player.isAlive()&&event.player!=player;
				},
				content(){
					'step 0'
					trigger.player.loseHp();
					'step 1'
					player.loseHp();
				}
			},
			enze:{
				enable:'phaseUse',
				usable:1,
				filterTarget(card,player,target){
					return player.countCards('h')!=target.countCards('h');
				},
				// alter:true,
				content(){
					var num=player.countCards('h')-target.countCards('h');
					if(num>0){
						if(num>3){
							num=3;
						}
						target.draw(num);
					}
					else if(num<0){
						if(num<-3){
							num=-3;
						}
						target.chooseToDiscard(-num,true);
					}
				},
				ai:{
					threaten:1.8,
					order(name,player){
						var max=true,num=0;
						var players=game.filterPlayer();
						for(var i=0;i<players.length;i++){
							if(players[i]==player) continue;
							var att=get.attitude(player,players[i]);
							var dh=player.countCards('h')-players[i].countCards('h');
							if(att*dh>num){
								if(att>0){
									max=true;
								}
								else if(att<0){
									max=false;
								}
								num=att*dh;
							}
						}
						if(max) return 10;
						return 0.5;
					},
					result:{
						player(player,target){
							return (player.countCards('h')-target.countCards('h'))*get.attitude(player,target);
						}
					},
					expose:0.2
				}
			},
			oldenze:{
				enable:'phaseUse',
				usable:1,
				filterTarget(card,player,target){
					return player.countCards('h')!=target.countCards('h');
				},
				// alter:true,
				content(){
					var num=player.countCards('h')-target.countCards('h');
					if(num>0){
						target.draw(num);
					}
					else if(num<0){
						target.chooseToDiscard(-num,true);
					}
				},
				ai:{
					threaten:1.8,
					order(name,player){
						var max=true,num=0;
						var players=game.filterPlayer();
						for(var i=0;i<players.length;i++){
							if(players[i]==player) continue;
							var att=get.attitude(player,players[i]);
							var dh=player.countCards('h')-players[i].countCards('h');
							if(att*dh>num){
								if(att>0){
									max=true;
								}
								else if(att<0){
									max=false;
								}
								num=att*dh;
							}
						}
						if(max) return 10;
						return 0.5;
					},
					result:{
						player(player,target){
							return (player.countCards('h')-target.countCards('h'))*get.attitude(player,target);
						}
					},
					expose:0.2
				}
			},
			chongsheng:{
				unique:true,
				enable:'chooseToUse',
				mark:true,
				init(player){
					player.storage.chongsheng=2;
					player.syncStorage('chongsheng');
				},
				filter(event,player){
					if(event.type!='dying') return false;
					if(player!=event.dying) return false;
					if(player.storage.chongsheng<=0) return false;
					return true;
				},
				content(){
					'step 0'
					player.hp=Math.min(player.storage.chongsheng,player.maxHp);
					player.discard(player.getCards('hej'));
					player.draw(player.storage.chongsheng);
					player.storage.chongsheng--;
					if(player.storage.chongsheng<=0){
						player.unmarkSkill('chongsheng');
					}
					'step 1'
					if(player.isLinked()) player.link();
					'step 2'
					if(player.isTurnedOver()) player.turnOver();
					player.syncStorage('chongsheng');
				},
				ai:{
					skillTagFilter(player){
						if(player.storage.chongsheng<=0) return false;
						if(player.hp>0) return false;
					},
					save:true,
					result:{
						player:10
					},
					threaten(player,target){
						if(target.storage.chongsheng>0) return 0.6;
					}
				},
				intro:{
					content:'time'
				}
			},
			guozai:{
				enable:'phaseUse',
				usable:1,
				// alter:true,
				filter(event,player){
					return player.countCards('h')<(get.is.altered('guozai')?3:4);
				},
				init(player){
					player.storage.guozai2=0;
				},
				content(){
					var num=(get.is.altered('guozai')?3:4)-player.countCards('h');
					player.draw(num);
					player.addSkill('guozai2');
					player.storage.guozai2+=num;
					game.addVideo('storage',player,['guozai2',player.storage.guozai2]);
				},
				ai:{
					order:1,
					result:{
						player:1
					}
				}
			},
			guozai2:{
				mark:true,
				intro:{
					content:'结束阶段需弃置&张牌'
				},
				trigger:{player:'phaseUseEnd'},
				forced:true,
				content(){
					player.chooseToDiscard('he',true,player.storage.guozai2);
					player.storage.guozai2=0;
					player.removeSkill('guozai2');
				}
			},
			guozaix:{
				enable:'phaseUse',
				usable:2,
				filter(event,player){
					return player.countCards('h')<4;
				},
				init(player){
					player.storage.guozaix2=0;
				},
				content(){
					var num=4-player.countCards('h');
					player.draw(num);
					player.addSkill('guozaix2');
					player.storage.guozaix2+=num;
					game.addVideo('storage',player,['guozaix2',player.storage.guozaix2]);
				},
				ai:{
					order:1,
					result:{
						player:1
					}
				}
			},
			guozaix2:{
				mark:true,
				intro:{
					content:'结束阶段需弃置&张牌'
				},
				trigger:{player:'phaseUseEnd'},
				forced:true,
				content(){
					player.chooseToDiscard('he',true,player.storage.guozaix2);
					player.storage.guozaix2=0;
					player.removeSkill('guozaix2');
				}
			},
			hanshuang:{
				trigger:{source:'damageEnd'},
				forced:true,
				// alter:true,
				filter(event,player){
					if(event._notrigger.includes(event.player)) return false;
					return event.card&&get.color(event.card)=='black'&&
					!event.player.isTurnedOver()&&event.player.isAlive();
				},
				content(){
					trigger.player.turnOver();
					if(get.is.altered('hanshuang')) trigger.player.draw();
					player.loseHp();
				},
				ai:{
					threaten:1.5,
					effect:{
						player(card,player,target,current){
							if(get.color(card)=='black'&&get.tag(card,'damage')){
								return [1,0,1,-2];
							}
						}
					}
				}
			},
			oldhanshuang:{
				trigger:{source:'damageEnd'},
				forced:true,
				// alter:true,
				filter(event,player){
					if(event._notrigger.includes(event.player)) return false;
					return event.card&&get.color(event.card)=='black'&&
					!event.player.isTurnedOver()&&event.player.isAlive();
				},
				content(){
					trigger.player.turnOver();
				},
				ai:{
					threaten:1.5,
					effect:{
						player(card,player,target,current){
							if(get.color(card)=='black'&&get.tag(card,'damage')){
								return [1,0,1,-2];
							}
						}
					}
				}
			},
			bingshi:{
				global:'bingshi2'
			},
			bingshi2:{
				trigger:{global:'dieAfter'},
				forced:true,
				globalFixed:true,
				filter(event,player){
					return event.player.hasSkill('bingshi')&&event.player.isDead();
				},
				content(){
					trigger.player.line(player,'thunder');
					player.damage('nosource','thunder').animate=false;
					player.$damage(trigger.player);
					player.$damagepop(-1,'thunder');
					if(lib.config.animation&&!lib.config.low_performance){
						player.$thunder();
					}
					if(!event.parent.parent.bingshi_logv){
						event.parent.parent.bingshi_logv=true;
						game.logv(trigger.player,'bingshi',game.filterPlayer(),event.parent.parent);
					}
				}
			},
			huanwu:{
				enable:'phaseUse',
				usable:1,
				filterTarget(card,player,target){
					return !target.storage.huanwu;
				},
				content(){
					target.gainMaxHp();
					target.recover();
					target.draw(2);
					target.storage.huanwu=true;
					target.mark('huanwu',{
						name:'唤雾',
						content:'已发动'
					});
					game.addVideo('mark',target,{
						name:'唤雾',
						content:'已发动',
						id:'huanwu'
					});
				},
				ai:{
					threaten:1.2,
					result:{
						target(player,target){
							return 1/target.hp;
						}
					},
					order:10,
					expose:0.3
				}
			},
			fengnu:{
				mod:{
					cardUsable(card){
						if(get.info(card)&&get.info(card).forceUsable) return;
						return Infinity;
					},
					targetInRange(){
						if(!get.is.altered('fengnu')) return true;
					}
				},
				// alter:true,
				trigger:{player:'useCard'},
				filter(event,player){
					if(_status.currentPhase!=player) return false;
					return player.countUsed(event.card)>1;
				},
				forced:true,
				usable:3,
				content(){
					player.draw();
				}
			},
			shengdun:{
				trigger:{player:'phaseBegin'},
				forced:true,
				filter(event,player){
					return !player.hujia;
				},
				content(){
					player.changeHujia();
					player.update();
				},
			},
			shengdun_old:{
				trigger:{player:'phaseBegin'},
				silent:true,
				priority:10,
				init2(player){
					player.markSkill('shengdun');
				},
				content(){
					if(player.storage.shengdun){
						player.markSkill('shengdun');
					}
					player.storage.shengdun=false;
				},
				intro:{
					content:'未发动'
				},
				group:'shengdun2'
			},
			shengdun_old2:{
				trigger:{player:'damageBegin'},
				forced:true,
				filter(event,player){
					return event.num>0&&!player.storage.shengdun;
				},
				content(){
					trigger.num--;
					player.storage.shengdun=true;
					player.unmarkSkill('shengdun');
				}
			},
			jingmeng:{
				trigger:{player:'useCard'},
				frequent:true,
				filter(event,player){
					return _status.currentPhase==player&&player.countUsed()==1;
				},
				content(){
					var type=get.type(trigger.card);
					var card=get.cardPile2(function(card){
						return get.type(card)==type;
					});
					if(card){
						player.gain(card,'gain2','log');
					}
				},
				ai:{
					threaten:1.1
				}
			},
			kuixin_old:{
				trigger:{player:'phaseEnd'},
				direct:true,
				filter(event,player){
					var nh=player.countCards('h');
					var nm=1;
					return game.hasPlayer(function(current){
						if(current!=player&&Math.abs(current.countCards('h')-nh)<=nm){
							return true;
						}
					});
				},
				content(){
					'step 0'
					var nh=player.countCards('h');
					var nm=1;
					var check=true;
					if(player.countCards('h','tao')){
						check=false;
					}
					else if(player.countCards('h','shan')&&player.countCards('h','wuxie')){
						check=false;
					}
					player.chooseTarget(get.prompt('kuixin'),function(card,player,target){
						return target!=player&&Math.abs(target.countCards('h')-nh)<=nm;
					}).ai=function(target){
						if(!check) return 0;
						if(get.attitude(player,target)<0){
							return target.countCards('h')-nh;
						}
						return 0;
					};
					'step 1'
					if(result.bool){
						var target=result.targets[0];
						player.logSkill('kuixin',result.targets);
						var cards0=target.getCards('h');
						var cards1=player.getCards('h');
						target.gain(cards1,player);
						player.gain(cards0,target);
						target.$give(cards0.length,player);
						player.$give(cards1.length,target);
					}
				},
				ai:{
					expose:0.2,
					threaten:1.5
				}
			},
			hswuji:{
				trigger:{player:'phaseUseEnd'},
				frequent:true,
				filter(event,player){
					return player.countUsed()>0;
				},
				content(){
					player.draw(player.countUsed());
				},
				ai:{
					threaten:1.3
				}
			},
			bingshuang:{
				trigger:{source:'damageEnd'},
				filter(event,player){
					if(event._notrigger.includes(event.player)) return false;
					return event.card&&get.type(event.card)=='trick'&&
					event.player.isAlive()&&!event.player.isTurnedOver();
				},
				check(event,player){
					if(event.player.hasSkillTag('noturn')) return;
					if(event.player.isTurnedOver()){
						return get.attitude(player,event.player)>0;
					}
					return get.attitude(player,event.player)<=0;
				},
				logTarget:'player',
				content(){
					trigger.player.draw(2);
					trigger.player.turnOver();
				}
			},
			yanshu:{
				trigger:{player:'discardAfter'},
				frequent:true,
				usable:1,
				filter(event,player){
					if(!event.cards) return false;
					for(var i=0;i<event.cards.length;i++){
						if(get.type(event.cards[i])!='basic') return true;
					}
					return false;
				},
				content(){
					player.gain(game.createCard('liuxinghuoyu','red'),'gain2');
				},
			},
			oldyanshu:{
				trigger:{player:'discardAfter'},
				frequent:true,
				filter(event,player){
					if(!event.cards) return false;
					for(var i=0;i<event.cards.length;i++){
						if(get.type(event.cards[i])!='basic') return true;
					}
					return false;
				},
				content(){
					player.gain(game.createCard('liuxinghuoyu','red'),'gain2');
				},
			},
			yanshu_old:{
				enable:'phaseUse',
				usable:1,
				filter(event,player){
					return player.countCards('h',{type:'basic'})<player.countCards('h');
				},
				filterCard(card){
					return get.type(card)!='basic';
				},
				check(card){
					return 6-get.value(card);
				},
				content(){
					var card=cards[0];
					var card2=get.cardPile('liuxinghuoyu');
					if(!card2){
						card2=game.createCard('liuxinghuoyu',get.suit(card),get.number(card));
					}
					player.gain(card2,'gain2');
				},
				ai:{
					order:9,
					result:{
						player:1
					},
					threaten:2
				}
			},
			shengyan:{
				trigger:{global:'recoverEnd'},
				filter(event,player){
					return !player.hasSkill('shengyan2')&&event.player.hp<event.player.maxHp;
				},
				logTarget:'player',
				check(event,player){
					return get.attitude(player,event.player)>0;
				},
				content(){
					trigger.player.recover();
					player.addTempSkill('shengyan2');
				},
				ai:{
					expose:0.2
				}
			},
			shengyan2:{},
			liechao:{
				enable:'phaseUse',
				usable:1,
				// alter:true,
				filter(event,player){
					return !player.isTurnedOver()&&player.countCards('h')<=player.hp;
				},
				content(){
					player.draw(get.is.altered('liechao')?3:4);
					player.turnOver();
					player.skip('phaseDiscard');
				},
				ai:{
					order:10,
					result:{
						player:1
					}
				}
			},
			qingliu:{
				trigger:{player:'damageBefore'},
				filter(event){
					return event.nature=='fire';
				},
				forced:true,
				content(){
					trigger.cancel();
				},
				ai:{
					nofire:true,
					effect:{
						target(card,player,target,current){
							if(get.tag(card,'fireDamage')) return 0;
						}
					}
				}
			},
			zhongjia:{
				trigger:{player:'damageEnd'},
				forced:true,
				filter(event){
					return event.num>0;
				},
				content(){
					player.changeHujia();
				},
				ai:{
					nohujia:true,
					maixie:true,
					maixie_hp:true,
					skillTagFilter(player){
						return player.hp>player.countCards('h')&&player.hp>1;
					},
					threaten(player,target){
						if(!target.hujia) return 0.8;
					},
					effect:{
						target(card,player,target){
							if(get.tag(card,'damage')){
								if(player.hasSkillTag('jueqing',false,target)) return [1,-1];
								return 0.8;
							}
						}
					}
				}
			},
			dunji:{
				enable:'phaseUse',
				usable:1,
				filter(event,player){
					return player.hujia?true:false;
				},
				filterTarget(card,player,target){
					return player!=target&&get.distance(player,target,'attack')<=1;
				},
				selectTarget(){
					return [1,_status.event.player.hujia];
				},
				contentBefore(){
					player.changeHujia(-targets.length);
				},
				content(){
					target.damage();
				},
				ai:{
					order:9,
					result:{
						target(player,target){
							var eff=get.damageEffect(target,player,target)+0.5;
							if(eff>0&&eff<=0.5) return 0;
							return eff;
						}
					}
				}
			},
			fengxing:{
				trigger:{player:'loseEnd'},
				direct:true,
				filter(event,player){
					return _status.currentPhase!=player&&!player.hasSkill('fengxing2')&&player.countCards('he')>0;
				},
				content(){
					'step 0'
					player.addTempSkill('fengxing2');
					player.chooseToDiscard('he',get.prompt('fengxing')).set('ai',function(card){
						return 7-get.value(card);
					}).set('autodelay',0.5).logSkill='fengxing';
					'step 1'
					if(result.bool){
						player.draw(2);
					}
				},
				ai:{
					threaten:0.6
				}
			},
			fengxing2:{},
			fengxian:{
				enable:'phaseUse',
				usable:1,
				filterTarget(card,player,target){
					return target.countCards('h')>0;
				},
				selectTarget:-1,
				content(){
					target.chooseToDiscard(true);
				},
				ai:{
					order:8,
					result:{
						target(player,target){
							var nh=target.countCards('h');
							switch(nh){
								case 0:return 0;
								case 1:return -1.5;
								case 2:return -1.3;
								case 3:return -1;
								default:return -0.8;
							}
						}
					}
				}
			},
			qiaodong:{
				enable:['chooseToUse','chooseToRespond'],
				filterCard:{type:'equip'},
				filter(event,player){
					return player.countCards('he',{type:'equip'})>0;
				},
				viewAs:{name:'shan'},
				position:'he',
				prompt:'将一张装备牌当闪使用或打出',
				check(){return 1},
				ai:{
					respondShan:true,
					skillTagFilter(player){
						if(!player.countCards('he',{type:'equip'})) return false;
					}
				}
			},
			hsmengjing_mengye:{
				trigger:{player:'phaseEnd'},
				forced:true,
				priority:-1,
				filter(event,player){
					return player.countCards('he')>0;
				},
				content(){
					player.discard(player.getCards('he'));
					player.removeSkill('hsmengjing_mengye');
				},
				mark:'image',
				intro:{
					content:'结束阶段，弃置所有牌'
				}
			},
			zhanhou:{
				enable:'phaseUse',
				filterCard:{subtype:'equip2'},
				position:'he',
				usable:1,
				filter(event,player){
					return player.countCards('he',{subtype:'equip2'})>0;
				},
				check(card){
					return 7-get.value(card);
				},
				content(){
					player.changeHujia();
				},
				ai:{
					order:9.5,
					result:{
						player:1
					}
				},
				// mod:{
				// 	globalFrom(from,to,distance){
				// 		return distance-from.hujia;
				// 	}
				// },
			},
			oldzhanhou:{
				enable:'phaseUse',
				filterCard:{subtype:'equip2'},
				position:'he',
				filter(event,player){
					return player.countCards('he',{subtype:'equip2'})>0;
				},
				check(card){
					if(get.position(card)=='e') return 0;
					return 7-get.value(card);
				},
				content(){
					player.changeHujia();
				},
				ai:{
					order:6,
					result:{
						player:1
					}
				}
			},
			shijie:{
				trigger:{player:'phaseEnd'},
				direct:true,
				filter(event,player){
					return game.hasPlayer(function(current){
						return current!=player&&current.countCards('h');
					});
				},
				content(){
					'step 0'
					player.chooseTarget(get.prompt('shijie'),function(card,player,target){
						return player!=target&&target.countCards('h')>0;
					}).ai=function(target){
						return 11-get.attitude(player,target);
					};
					'step 1'
					if(result.bool){
						player.logSkill('shijie',result.targets);
						var target=result.targets[0];
						var card=target.getCards('h').randomGet()
						player.gain(card,target);
						event.target=target;
						target.$giveAuto(card,player);
						event.target.draw();
					}
				},
				ai:{
					expose:0.1
				}
			},
			shengguang:{
				enable:'phaseUse',
				filterCard:{color:'red'},
				filter(event,player){
					return player.countCards('he',{color:'red'})>0;
				},
				position:'he',
				usable:1,
				check(card){
					return 9-get.value(card)
				},
				filterTarget(card,player,target){
					if(player.storage.anying) return true;
					if(target.hp>=target.maxHp) return false;
					return true;
				},
				content(){
					if(player.storage.anying){
						target.loseHp();
					}
					else{
						target.recover();
					}
				},
				ai:{
					order:9,
					result:{
						target(player,target){
							if(player.storage.anying) return -1;
							if(target.hp==1) return 5;
							if(player==target&&player.countCards('h')>player.hp) return 5;
							return 2;
						}
					},
					threaten:2,
					expose:0.2
				}
			},
			xinci:{
				enable:'phaseUse',
				filterCard:{color:'black'},
				filter(event,player){
					return player.countCards('he',{color:'black'})>0;
				},
				position:'he',
				usable:1,
				mark:true,
				intro:{
					content:'已进入暗影形态'
				},
				check(card){
					return 9-get.value(card)
				},
				filterTarget:true,
				content(){
					target.loseHp();
				},
				ai:{
					order:9,
					result:{
						target:-1
					},
					threaten:2,
					expose:0.2
				}
			},
			anying:{
				unique:true,
				enable:'phaseUse',
				skillAnimation:'epic',
				animationColor:'thunder',
				derivation:'xinci',
				filter(event,player){
					return !player.storage.anying&&player.countCards('he',{color:'black'})>0;
				},
				filterCard:{color:'black'},
				position:'he',
				check(card){
					return 5-get.value(card);
				},
				content(){
					player.storage.anying=true;
					player.awakenSkill('anying');
					player.removeSkill('shengguang');
					player.addAdditionalSkill('anying','xinci');
				},
				ai:{
					order:1,
					result:{
						player(player){
							if(player.hasUnknown()) return 0;
							return !game.hasPlayer(function(current){
								return get.attitude(player,current)>0&&current.isDamaged()&&current.hp<=2;
							});
						}
					}
				}
			},
			huanjue:{
				trigger:{player:'useCard1'},
				frequent:true,
				filter(event,player){
					if(event._huanjue) return false;
					if(event.targets.length!=1) return false;
					var target=event.targets[0];
					for(var i=0;i<lib.inpile.length;i++){
						var info=lib.card[lib.inpile[i]];
						if(info.multitarget) continue;
						if(lib.filter.targetEnabled2({name:lib.inpile[i]},event.player,target)){
							return true;
						}
					}
					return false;
				},
				// check(event,player){
				// 	var eff=get.effect(event.targets[0],event.card,event.player,player);
				// 	if(eff<=0) return true;
				// 	if(get.value(event.card,event.player,'raw')<5){
				// 		return true;
				// 	}
				// 	return false;
				// },
				// prompt2(event,player){
				// 	return '发现一张牌代替你对'+get.translation(event.targets[0])+'使用的'+get.translation(event.card);
				// },
				autodelay:true,
				content(){
					'step 0'
					var list=[],list1=[],list2=[];
					for(var i=0;i<lib.inpile.length;i++){
						var info=lib.card[lib.inpile[i]];
						if(info.multitarget) continue;
						if(lib.filter.targetEnabled2({name:lib.inpile[i]},trigger.player,trigger.targets[0])){
							var cardinfo=[trigger.card.suit||'',trigger.card.number||'',lib.inpile[i]];
							list1.push(cardinfo);
							if(info.type!='equip'){
								list2.push(cardinfo);
							}
						}
					}
					var equipped=false;
					for(var i=0;i<3;i++){
						if(equipped&&list2.length){
							list.push(list2.randomRemove());
						}
						else{
							equipped=true;
							list.push(list1.randomRemove());
						}
					}
					var eff1=get.effect(trigger.targets[0],trigger.card,trigger.player,player);
					var val1=get.value(trigger.card,player,'raw');
					player.chooseButton(['幻觉',[list,'vcard']]).ai=function(button){
						var card={suit:trigger.card.suit,number:trigger.card.number,name:button.link[2]};
						var eff2=get.effect(trigger.targets[0],card,trigger.player,player)
						var val2=get.value(card,player,'raw');
						if(eff1>0){
							if(eff2<=0) return 0;
							return val2-val1;
						}
						else if(eff1<0){
							if(eff2>=0) return val2;
							return 0;
						}
						else if(eff1==0){
							if(eff2>0) return val2;
							return 0;
						}
					};
					'step 1'
					if(result.bool){
						var stat=player.stat[player.stat.length-1].card;
						if(stat[trigger.card.name]){
							stat[trigger.card.name]--;
						}
						var card=game.createCard({
							suit:trigger.card.suit||lib.suit.randomGet(),
							number:trigger.card.number||Math.ceil(Math.random()*13),
							name:result.links[0][2]}
						);
						event.card=card;
						game.log(player,'将',trigger.card,'变为',card);
						// if(!event.isMine()) game.delayx();
						trigger.card=get.autoViewAs(card);
						trigger.cards=[card];
						game.cardsGotoOrdering(card).relatedEvent=trigger;
						trigger._huanjue=true;
					}
					else{
						event.finish();
					}
					'step 2'
					player.$throw(event.card,null,null,true);
					if(player==trigger.player){
						player.line(trigger.targets[0],'green');
					}
					else{
						player.line(trigger.player,'green');
					}
					game.delayx(0.5);
					'step 3'
					var stat=player.stat[player.stat.length-1].card;
					if(!stat[trigger.card.name]){
						stat[trigger.card.name]=1;
					}
					else{
						stat[trigger.card.name]++;
					}
				},
				draw(){
					player.draw();
				},
				ai:{
					usedu:true
				}
			},
			huanjue_old:{
				trigger:{global:'useCard'},
				usable:1,
				filter(event,player){
					if(event.targets.length!=1) return false;
					var target=event.targets[0];
					if(event.player==target) return false;
					if(player!=event.player&&player!=target) return false;
					for(var i=0;i<lib.inpile.length;i++){
						var info=lib.card[lib.inpile[i]];
						if(info.multitarget) continue;
						if(lib.filter.targetEnabled2({name:lib.inpile[i]},event.player,target)){
							return true;
						}
					}
					return false;
				},
				check(event,player){
					var eff=get.effect(event.targets[0],event.card,event.player,player);
					if(eff<=0) return true;
					if(get.value(event.card,event.player,'raw')<5){
						return Math.random()<0.5;
					}
					return false;
				},
				prompt2(event,player){
					var name1,name2;
					if(player==event.player){
						name1='你';
						name2=get.translation(event.targets[0]);
					}
					else{
						name1=get.translation(event.player);
						name2='你';
					}
					return '从三张随机牌中选择一张代替'+name1+'对'+name2+'使用的'+get.translation(event.card);
				},
				autodelay:true,
				content(){
					'step 0'
					var list=[],list1=[],list2=[];
					for(var i=0;i<lib.inpile.length;i++){
						var info=lib.card[lib.inpile[i]];
						if(info.multitarget) continue;
						if(lib.filter.targetEnabled2({name:lib.inpile[i]},trigger.player,trigger.targets[0])){
							var cardinfo=[trigger.card.suit||'',trigger.card.number||'',lib.inpile[i]];
							list1.push(cardinfo);
							if(info.type!='equip'){
								list2.push(cardinfo);
							}
						}
					}
					var equipped=false;
					for(var i=0;i<3;i++){
						if(equipped&&list2.length){
							list.push(list2.randomRemove());
						}
						else{
							equipped=true;
							list.push(list1.randomRemove());
						}
					}
					player.chooseButton(true,['幻觉',[list,'vcard']]).ai=function(button){
						var card={suit:trigger.card.suit,number:trigger.card.number,name:button.link[2]};
						return get.effect(trigger.targets[0],card,trigger.player,player);
					};
					'step 1'
					if(result.bool){
						var card=game.createCard({
							suit:trigger.card.suit||lib.suit.randomGet(),
							number:trigger.card.number||Math.ceil(Math.random()*13),
							name:result.links[0][2]}
						);
						event.card=card;
						game.log(player,'将',trigger.card,'变为',card);
						trigger.card=get.autoViewAs(card);
						trigger.cards=[card];
						game.cardsGotoOrdering(card);
					}
					else{
						event.finish();
					}
					'step 2'
					player.$throw(event.card,null,null,true);
					if(player==trigger.player){
						player.line(trigger.targets[0],'green');
					}
					else{
						player.line(trigger.player,'green');
					}
					game.delayx(0.5);
					'step 3'
					trigger.insertAfter(lib.skill.huanjue.draw,{player:trigger.player});
				},
				draw(){
					player.draw();
				},
				ai:{
					expose:0.2,
					threaten(player,target){
						if(target.storage.counttrigger&&target.storage.counttrigger.huanjue) return 1.8;
						return 0.6;
					}
				}
			},
			bingjia:{
				enable:'phaseUse',
				filter(event,player){
					return !player.hasSkill('bingjia2');
				},
				filterCard:true,
				check(card){
					return 6-get.value(card);
				},
				discard:false,
				prepare(cards,player){
					player.$give(1,player,false);
				},
				content(){
					player.storage.bingjia=cards[0];
					player.addSkill('bingjia2');
					game.addVideo('storage',player,['bingjia',get.cardInfo(cards[0]),'card']);
				},
				ai:{
					order:1,
					result:{
						player:1
					}
				}
			},
			bingjia2:{
				mark:true,
				trigger:{target:'useCardToBegin'},
				forced:true,
				filter(event,player){
					return event.player!=player&&get.suit(event.card)==get.suit(player.storage.bingjia);
				},
				content(){
					'step 0'
					player.showCards([player.storage.bingjia],get.translation(player)+'发动了【冰甲】');
					player.removeSkill('bingjia2');
					game.addVideo('storage',player,['bingjia',null]);
					'step 1'
					player.storage.bingjia.discard();
					delete player.storage.bingjia;
					player.changeHujia();
					player.addTempSkill('mianyi');
				},
				intro:{
					mark(dialog,content,player){
						if(player==game.me||player.isUnderControl()){
							dialog.add([player.storage.bingjia]);
						}
						else{
							return '已发动冰甲';
						}
					},
					content(content,player){
						if(player==game.me||player.isUnderControl()){
							return get.translation(player.storage.bingjia);
						}
						return '已发动冰甲';
					}
				}
			},
			bianxing2:{},
			zuzhou:{
				trigger:{player:'phaseBegin'},
				filter(event,player){
					if(!player.countCards('h',{suit:'spade'})) return false;
					return !game.hasPlayer(function(current){
						return current.hasJudge('fulei');
					});
				},
				forced:true,
				check(){
					return false;
				},
				content(){
					var card=game.createCard('fulei');
					player.addJudge(card);
					player.$draw(card);
					game.delay(2);
				},
				ai:{
					threaten:1.5
				},
				group:'zuzhou_remove',
				subSkill:{
					remove:{
						trigger:{global:'damageEnd'},
						filter(event,player){
							return event.card&&event.card.name=='fulei';
						},
						forced:true,
						content(){
							trigger.card.expired=true;
							game.log(trigger.card,'被移去');
						}
					}
				}
			},
			mdzhoufu:{
				enable:'phaseUse',
				filterCard:{color:'black'},
				filter(event,player){
					return player.countCards('h',{color:'black'})>0;
				},
				filterTarget(card,player,target){
					return player!=target&&!target.hasSkill('mdzhoufu2');
				},
				prepare:'throw',
				discard:false,
				content(){
					target.$gain2(cards);
					target.storage.mdzhoufu2=cards[0];
					target.addSkill('mdzhoufu2');
					target.storage.mdzhoufu3=player;
					game.addVideo('storage',target,['mdzhoufu2',get.cardInfo(cards[0]),'card']);
					ui.special.appendChild(cards[0]);
				},
				check(card){
					if(get.suit(card)=='spade'){
						return 6-get.value(card);
					}
					return -1;
				},
				ai:{
					tag:{
						rejudge:0.1,
					},
					threaten:1.5,
					expose:0.1,
					order:10,
					result:{
						target:-1
					}
				}
			},
			mdzhoufu2:{
				trigger:{player:'judge'},
				forced:true,
				priority:10,
				mark:'card',
				content(){
					"step 0"
					player.storage.mdzhoufu2.discard();
					player.$throw(player.storage.mdzhoufu2);
					if(player.storage.mdzhoufu2.clone){
						player.storage.mdzhoufu2.clone.classList.add('thrownhighlight');
						game.addVideo('highlightnode',player,get.cardInfo(player.storage.mdzhoufu2));
					}
					if(player.storage.mdzhoufu3.isIn()){
						player.storage.mdzhoufu3.line(player,'green');
						player.storage.mdzhoufu3.gain(player.judging[0]);
						player.storage.mdzhoufu3.$gain2(player.judging[0]);
					}
					else{
						player.judging[0].discard();
						game.delay(1.5);
					}
					player.removeSkill('mdzhoufu2');
					"step 1"
					player.judging[0]=player.storage.mdzhoufu2;
					trigger.position.appendChild(player.storage.mdzhoufu2);
					// trigger.untrigger();
					game.log(player,'的判定牌改为',player.storage.mdzhoufu2);
					delete player.storage.mdzhoufu2;
					delete player.storage.mdzhoufu3;
				},
				intro:{
					content:'card'
				},
			},
			zuzhou_old:{
				trigger:{player:'damageEnd',source:'damageEnd'},
				check(event,player){
					var target=(player==event.player)?event.source:event.player;
					return get.attitude(player,target)<0;
				},
				filter(event,player){
					var target=(player==event.player)?event.source:event.player;
					return target.isAlive();
				},
				prompt(event,player){
					var target=(player==event.player)?event.source:event.player;
					return get.prompt('zuzhou',target);
				},
				content(){
					"step 0"
					event.target=(player==trigger.player)?trigger.source:trigger.player;
					event.target.judge(function(card){
						return get.color(card)=='black'?-1:0;
					});
					"step 1"
					if(result.color=='black'){
						event.target.loseHp();
					}
				},
				ai:{
					expose:0.1,
					threaten:1.3
				}
			},
			xianzhi:{
				trigger:{global:'judgeBegin'},
				frequent:true,
				filter(){
					return ui.cardPile.childNodes.length>1;
				},
				check(){
					return false;
				},
				content(){
					'step 0'
					var str='';
					if(trigger.card) str=get.translation(trigger.card.viewAs||trigger.card.name);
					else if(trigger.skill) str=get.translation(trigger.skill);
					else str=get.translation(trigger.parent.name);

					var cards=[ui.cardPile.childNodes[0],ui.cardPile.childNodes[1]];
					var att=get.attitude(player,trigger.player);
					var delta=trigger.judge(ui.cardPile.childNodes[1])-trigger.judge(ui.cardPile.childNodes[0]);
					player.chooseControl('调换顺序','cancel2',
					ui.create.dialog('先知：'+get.translation(trigger.player)+'的'+str+'判定',cards,'hidden')).ai=function(){
						if(att*delta>0) return '调换顺序';
						else return 'cancel2';
					};
					'step 1'
					if(result.control=='调换顺序'){
						var card=ui.cardPile.firstChild;
						ui.cardPile.removeChild(card);
						ui.cardPile.insertBefore(card,ui.cardPile.firstChild.nextSibling);
						game.log(player,'调换了牌堆顶两张牌的顺序');
					}
				},
				ai:{
					expose:0.1,
					tag:{
						rejudge:0.5
					}
				}
			},
			jingxiang:{
				trigger:{player:'chooseToRespondBegin'},
				direct:true,
				usable:1,
				// alter:true,
				filter(event,player){
					if(event.responded) return false;
					return game.hasPlayer(function(current){
						return current!=player&&current.countCards('h');
					});
				},
				content(){
					"step 0"
					player.chooseTarget(get.prompt('jingxiang'),function(card,player,target){
						if(target==player) return false;
						var nh=target.countCards('h');
						if(nh==0) return false;
						if(get.is.altered('jingxiang')){
							return nh<=player.countCards('h');
						}
						return true;
					}).ai=function(target){
						return 1-get.attitude(player,target);
					};
					"step 1"
					if(result.bool){
						var target=result.targets[0];
						player.logSkill('jingxiang',target);
						event.target=target;
						var cards=target.getCards('h');
						player.chooseCardButton('选择'+get.translation(target)+'的一张卡手牌打出',cards).filterButton=function(button){
							return trigger.filterCard(button.link);
						}
					}
					else{
						event.finish();
					}
					"step 2"
					if(result.bool){
						game.log(player,'使用了',event.target,'的手牌');
						event.target.$throw(result.links);
						event.target.lose(result.links);
						trigger.untrigger();
						trigger.animate=false;
						trigger.responded=true;
						result.buttons[0].link.remove();
						trigger.result={bool:true,card:result.buttons[0].link}
					}
					else{
						player.storage.counttrigger.jingxiang--;
					}
				},
				ai:{
					respondShan:true,
					effect:{
						target(card){
							if(get.tag(card,'respondShan')) return 0.4;
							if(get.tag(card,'respondSha')) return 0.4;
						}
					}
				},
			},
			wlianji:{
				trigger:{player:'phaseEnd'},
				frequent:true,
				filter(event,player){
					return player.countUsed()>player.hp;
				},
				content(){
					player.draw(2);
				},
				init(player){player.storage.jingce=true},
				intro:{
					content(storage,player){
						if(_status.currentPhase==player) return '已使用'+player.countUsed()+'张牌';
					}
				}
			},
			mengun:{
				trigger:{global:'useCardToBefore'},
				priority:12,
				filter(event,player){
					if(event.player==player) return false;
					if(_status.currentPhase!=event.player) return false;
					if(event.player.hasSkill('mengun2')) return false;
					if(get.itemtype(event.card)!='card') return false;
					if(!player.countCards('h',{suit:get.suit(event.card)})) return false;
					return get.type(event.card)=='basic';
				},
				direct:true,
				content(){
					"step 0"
					var val=get.value(trigger.card);
					var suit=get.suit(trigger.card);
					var eff=get.effect(trigger.target,trigger.card,trigger.player,player);
					var next=player.chooseToDiscard('是否对'+get.translation(trigger.player)+'使用的'+get.translation(trigger.card)+'发动【闷棍】？',function(card){
						return get.suit(card)==suit;
					});
					next.logSkill=['mengun',trigger.player];
					next.ai=function(card){
						if(eff>=0) return 0;
						return Math.min(8,1+val)-get.value(card);
					}
					"step 1"
					if(result.bool){
						game.log(trigger.player,'收回了',trigger.cards);
						trigger.cancel();
						game.delay();
					}
					else{
						event.finish();
					}
					"step 2"
					trigger.player.$gain2(trigger.cards);
					trigger.player.gain(trigger.cards);
					trigger.player.storage.mengun2=trigger.cards[0];
					game.addVideo('storage',player,['mengun2',get.cardInfo(trigger.cards[0]),'card']);
					trigger.player.addTempSkill('mengun2','phaseEnd');
				},
				ai:{
					expose:0.2
				}
			},
			mengun2:{
				mark:'card',
				mod:{
					cardEnabled(card,player){
						if(card==player.storage.mengun2) return false;
					},
				},
				intro:{
					content:'card',
					onunmark(storage,player){
						delete player.storage.mengun2;
					}
				},
			},
			jianren:{
				enable:'phaseUse',
				usable:1,
				filter(event,player){
					return player.getEquip(1)?true:false;
				},
				filterCard(card,player){
					return card==player.getEquip(1);
				},
				position:'e',
				filterTarget(card,player,target){
					return target!=player;
				},
				selectCard:-1,
				selectTarget:-1,
				content(){
					target.damage();
				},
				ai:{
					order:9,
					result:{
						target(player,target){
							return get.damageEffect(target,player,target);
						}
					}
				}
			},
			jihuo:{
				trigger:{player:'phaseAfter'},
				filter(event,player){
					return player.countCards('h')>0&&event.skill!='jihuo';
				},
				direct:true,
				priority:-50,
				content(){
					"step 0"
					var next=player.chooseToDiscard(get.prompt('jihuo'));
					next.ai=get.unuseful2;
					next.logSkill='jihuo';
					"step 1"
					if(result.bool){
						player.insertPhase();
					}
				},
				ai:{
					threaten:1.2
				}
			},
			tzhenji:{
				trigger:{player:'discardAfter'},
				direct:true,
				filter(event,player){
					if(player.hasSkill('tzhenji2')){
						return false;
					}
					if(event.cards){
						for(var i=0;i<event.cards.length;i++){
							if(get.color(event.cards[i])=='black') return true;
						}
					}
					return false;
				},
				content(){
					"step 0";
					player.chooseTarget(get.prompt('tzhenji')).ai=function(target){
						var bool=get.attitude(player,target)>0;
						return get.damageEffect(target,player,player,'thunder')-(bool?1:0);
					};
					"step 1"
					if(result.bool){
						game.delay(0.5);
						var target=result.targets[0];
						player.logSkill('tzhenji',target,'thunder');
						var cs=target.getCards('he');
						if(cs.length){
							target.discard(cs.randomGet());
						}
						target.damage('thunder');
						player.addTempSkill('tzhenji2');
					}
				},
				ai:{
					threaten:1.2,
					expose:0.3,
					effect:{
						target(card,player,target){
							if(get.tag(card,'loseCard')&&target.countCards('he')){
								return 0.7;
							}
						}
					},
				}
			},
			tzhenji2:{},
			tzhenji_old:{
				trigger:{player:['useCard','respondEnd']},
				filter(event){
					return get.suit(event.card)=='spade';
				},
				direct:true,
				content(){
					"step 0";
					player.chooseTarget(get.prompt('tzhenji_old')).ai=function(target){
						return get.damageEffect(target,player,player,'thunder')-1;
					};
					"step 1"
					if(result.bool){
						player.logSkill('tzhenji',result.targets,'thunder');
						event.target=result.targets[0];
						event.target.judge();
					}
					else{
						event.finish();
					}
					"step 2"
					if(result.color=='red'){
						event.target.damage('fire');
					}
					else{
						event.target.damage('thunder');
						var cs=event.target.getCards('he');
						if(cs.length){
							event.target.discard(cs.randomGet());
						}
						cs=player.getCards('he');
						if(cs.length){
							player.discard(cs.randomGet());
						}
					}
				},
				ai:{
					expose:0.2,
					threaten:1.2,
					effect_old:{
						target(card,player,target){
							if(get.tag(card,'respondShan')){
								var hastarget=game.hasPlayer(function(current){
									return get.attitude(player,current)<0;
								});
								var ns=target.countCards('h','shan');
								var nh=target.countCards('h');
								if(ns>1){
									return [0,hastarget?1:0];
								}
								if(ns&&nh>=2){
									return [0,0];
								}
								if(nh>3){
									return [0,0];
								}
								if(nh==0){
									return 1.5;
								}
								return [1,0.05];
							}
						}
					}
				}
			},
			tuteng_s:{
				trigger:{player:'phaseUseBegin'},
				forced:true,
				filter(event,player){
					var rand=['tuteng1','tuteng2','tuteng3','tuteng4'];
					for(var i=0;i<player.skills.length;i++){
						rand.remove(player.skills[i]);
						if(rand.length==0) return false;
					}
					return true;
				},
				content(){
					var rand=['tuteng1','tuteng2','tuteng3','tuteng4'];
					for(var i=0;i<player.skills.length;i++){
						rand.remove(player.skills[i]);
					}
					if(rand.length){
						player.addSkill(rand.randomGet());
					}
				},
				ai:{
					effect: {
						player(card,player,target){
							if(get.tag(card,'damage')){
								if(player.hasSkillTag('jueqing',false,target)) return [1,1];
								return 1.2;
							}
						},
					},
					threaten:1.3
				},
				group:'tuteng_lose'
			},
			s_tuteng:{
				trigger:{player:'phaseBegin'},
				forced:true,
				unique:true,
				content(){
					var rand=['tuteng1','tuteng2','tuteng3','tuteng4','tuteng5','tuteng6','tuteng7','tuteng8'];
					var rand2=[];
					for(var i=0;i<rand.length;i++){
						if(player.skills.includes(rand[i])){
							rand2.push(rand[i]);
							rand.splice(i--,1);
						}
					}
					if(rand2.length>=3){
						player.removeSkill(rand2.randomGet());
					}
					player.addSkill(rand.randomGet('tuteng1','tuteng3'));
				},
				ai:{
					threaten:2
				}
			},
			tuteng:{
				enable:'phaseUse',
				usable:1,
				unique:true,
				direct:true,
				delay:0,
				init(){
					for(var i=1;i<=8;i++){
						lib.translate['tuteng'+i+'_info']=lib.skill['tuteng'+i].intro.content;
					}
				},
				position:'he',
				filter(event,player){
					if(player.storage.tuteng_awake) return true;
					var rand=['tuteng1','tuteng2','tuteng3','tuteng4'];
					for(var i=0;i<rand.length;i++){
						if(!player.hasSkill(rand[i])) return true;
					}
					return false;
				},
				content(){
					'step 0'
					var rand=['tuteng1','tuteng2','tuteng3','tuteng4'];
					var rand2=[];
					var randx=[];
					var rand2x=[];
					if(player.storage.tuteng_awake){
						rand=rand.concat(['tuteng5','tuteng6','tuteng7','tuteng8']);
					}
					for(var i=0;i<player.skills.length;i++){
						if(rand.includes(player.skills[i])){
							rand.remove(player.skills[i]);
							rand2.push(player.skills[i]);
						}
					}
					if(!player.storage.tuteng_awake){
						player.addSkill(rand.randomGet());
						game.delay();
						event.finish();
						return;
					}
					if(rand.length){
						if(event.isMine()&&(rand.length>1||rand2.length>=4)){
							var dialog=ui.create.dialog();
							for(var i=0;i<rand.length;i++){
								randx[i]=['','',rand[i]];
							}
							for(var i=0;i<rand2.length;i++){
								rand2x[i]=['','',rand2[i]];
							}
							dialog.add('选择一个图腾');
							dialog.add([randx,'vcard']);
							if(rand2.length>=4){
								dialog.add('替换一个已有图腾');
								dialog.add([rand2x,'vcard']);
								player.chooseButton(dialog,2,true).filterButton=function(button){
									if(ui.selected.buttons.length){
										var current=ui.selected.buttons[0].name;
										if(rand.includes(current)){
											return rand2.includes(button.name);
										}
										else{
											return rand.includes(button.name);
										}
									}
									return true;
								};
							}
							else{
								player.chooseButton(dialog,true);
							}
							for(var i=0;i<dialog.buttons.length;i++){
								var item=dialog.buttons[i]
								if(i==4){
									item.parentNode.insertBefore(document.createElement('br'),item);
								}
								item.style.zoom=0.7;
							}
						}
						else{
							if(player.hp<player.maxHp&&rand.includes('tuteng1')){
								player.addSkill('tuteng1');
							}
							else{
								if(rand.length>1){
									rand.remove('tuteng1');
								}
								player.addSkill(rand.randomGet());
							}
							// if(rand2.length>=3){
							// 	player.removeSkill(rand2.randomGet());
							// }
							game.delay();
							event.finish();
						}
					}
					else{
						event.finish();
					}
					'step 1'
					if(result.buttons.length==1){
						player.addSkill(result.buttons[0].name);
					}
					else if(result.buttons.length==2){
						var skill1=result.buttons[0].name;
						var skill2=result.buttons[1].name;
						if(player.hasSkill(skill1)){
							player.removeSkill(skill1);
							player.addSkill(skill2);
						}
						else{
							player.removeSkill(skill2);
							player.addSkill(skill1);
						}
					}
				},
				ai:{
					order:11,
					result:{
						player:1
					},
					effect: {
						player(card,player,target){
							if(get.tag(card,'damage')){
								if(player.hasSkillTag('jueqing',false,target)) return;
								return 1.2;
							}
						},
					},
					threaten:2
				},
				group:'tuteng_lose'
			},
			zuling:{
				skillAnimation:'epic',
				animationColor:'thunder',
				trigger:{player:'phaseBegin'},
				forced:true,
				unique:true,
				filter(event,player){
					if(!player.storage.tuteng_awake){
						var rand=['tuteng1','tuteng2','tuteng3','tuteng4',
						'tuteng5','tuteng6','tuteng7','tuteng8'];
						var num=0;
						for(var i=0;i<player.skills.length;i++){
							if(rand.includes(player.skills[i])) num++;
							if(num>=3){
								return true;
							}
						}
					}
					return false;
				},
				content(){
					player.storage.tuteng_awake=true;
					player.loseMaxHp();
					player.awakenSkill('zuling');
				}
			},
			huanfeng:{
				skillAnimation:'epic',
				animationColor:'thunder',
				trigger:{player:'phaseBeginStart'},
				forced:true,
				unique:true,
				filter(event,player){
					// if(player.storage.huanfeng_awake) return false;
					var skills=['tuteng1','tuteng2','tuteng3','tuteng4'];
					for(var i=0;i<skills.length;i++){
						if(!player.hasSkill(skills[i])){
							return false;
						}
					}
					return true;
				},
				content(){
					// player.storage.huanfeng_awake=true;
					player.removeSkill('tuteng1');
					player.removeSkill('tuteng2');
					player.removeSkill('tuteng3');
					player.removeSkill('tuteng4');
					// player.awakenSkill('huanfeng');
					player.storage.huanfeng_end=player.addSubPlayer({
						name:'hs_alakir',
						hp:3,
						maxHp:3,
						skills:lib.character.hs_alakir[3],
						hs:get.cards(4)
					});
					player.callSubPlayer(player.storage.huanfeng_end);
					// if(lib.filter.filterTrigger(trigger,player,'phaseBegin','shengdun')) game.createTrigger('phaseBegin','shengdun',player,trigger);
				},
				// group:'huanfeng_end',
				subSkill:{
					end:{
						temp:true,
						vanish:true,
						trigger:{player:'phaseEnd'},
						silent:true,
						filter(event,player){
							return player.storage.huanfeng_end;
						},
						content(){
							player.insertPhase();
							delete player.storage.huanfeng_end;
						}
					}
				}
			},
			tuteng_h:{
				mod:{
					maxHandcard(player,num){
						return num-1;
					}
				}
			},
			tuteng_lose:{
				trigger:{player:'damageEnd'},
				forced:true,
				popup:false,
				filter(event,player){
					var tuteng=['tuteng1','tuteng2','tuteng3','tuteng4',
					'tuteng5','tuteng6','tuteng7','tuteng8'];
					for(var i=0;i<player.skills.length;i++){
						if(tuteng.includes(player.skills[i])) return true;
					}
					return false;
				},
				content(){
					var tuteng=['tuteng1','tuteng2','tuteng3','tuteng4',
					'tuteng5','tuteng6','tuteng7','tuteng8'];
					var rand=[];
					for(var i=0;i<player.skills.length;i++){
						if(tuteng.includes(player.skills[i])){
							rand.push(player.skills[i]);
						}
					}
					if(rand.length){
						player.removeSkill(rand.randomGet());
					}
				}
			},
			tuteng1:{
				mark:'image',
				nopop:true,
				intro:{
					content:'结束阶段，你回复1点体力'
				},
				trigger:{player:'phaseEnd'},
				forced:true,
				filter(event,player){
					return player.hp<player.maxHp;
				},
				content(){
					player.recover();
				}
			},
			tuteng2:{
				mark:'image',
				nopop:true,
				intro:{
					content:'每当你造成一次伤害，你摸一张牌'
				},
				trigger:{source:'damageAfter'},
				forced:true,
				content(){
					player.draw();
				}
			},
			tuteng3:{
				mark:'image',
				nopop:true,
				intro:{
					content:'你受到下一次伤害时，令伤害-1，然后失去此图腾'
				},
				trigger:{player:'damageBegin'},
				forced:true,
				filter(event){
					return event.num>0;
				},
				content(){
					trigger.num--;
					player.removeSkill('tuteng3');
				},
			},
			tuteng4:{
				mark:'image',
				nopop:true,
				intro:{
					content:'在你的回合内，你的锦囊牌造成的首次伤害+1'
				},
				trigger:{source:'damageBegin'},
				forced:true,
				usable:1,
				filter(event,player){
					return _status.currentPhase==player&&event.card&&get.type(event.card)=='trick'&&event.notLink();
				},
				content(){
					trigger.num++;
				}
			},
			tuteng5:{
				mark:'image',
				nopop:true,
				intro:{
					content:'结束阶段，你摸一张牌'
				},
				trigger:{player:'phaseEnd'},
				forced:true,
				content(){
					player.draw();
				}
			},
			tuteng6:{
				mark:'image',
				nopop:true,
				intro:{
					content:'在你的回合内，你的杀造成的首次伤害+1'
				},
				trigger:{source:'damageBegin'},
				forced:true,
				filter(event,player){
					return _status.currentPhase==player&&event.card&&event.card.name=='sha'&&event.notLink();
				},
				usable:1,
				content(){
					trigger.num++;
				}
			},
			tuteng7:{
				mark:'image',
				nopop:true,
				intro:{
					content:'结束阶段，你令一名其他角色回复1点体力'
				},
				trigger:{player:'phaseEnd'},
				direct:true,
				filter(event,player){
					return game.hasPlayer(function(current){
						return current!=player&&current.isDamaged();
					});
				},
				content(){
					'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('tuteng7',result.targets[0]);
						result.targets[0].recover();
					}
				}
			},
			tuteng8:{
				mark:'image',
				nopop:true,
				intro:{
					content:'进攻距离+1'
				},
				mod:{
					globalFrom(from,to,distance){
						return distance-1;
					}
				}
			},
			fenliu:{
				enable:'phaseUse',
				prompt:'失去1点体力并摸三张牌',
				usable:1,
				content(){
					"step 0"
					player.loseHp(1);
					"step 1"
					player.draw(3);
				},
				ai:{
					order:4,
					result:{
						player(player){
							var nh=player.countCards('h');
							if(nh>=player.hp) return -1;
							if(player.hp<=2){
								if(player.hp==2&&nh==0) return 1;
								return -1;
							}
							return 1;
						}
					},
					effect:{
						target(card){
							if(get.tag(card,'damage')||get.tag(card,'loseHp')){
								return 1.5;
							}
						}
					},
					threaten:1.2
				}
			},
			fenliu2:{
				mod:{
					maxHandcard(player,num){
						return num+1;
					}
				}
			},
			hongxi:{
				trigger:{global:'dieAfter'},
				filter(event,player){
					return player.hp<player.maxHp;
				},
				forced:true,
				content(){
					player.recover(player.maxHp-player.hp);
				},
				ai:{
					threaten:1.2
				}
			},
		},
		cardType:{
			hsfashu:0.5,
			hszuzhou:0.5,
			hsmengjing:0.5,
			hsbaowu:0.5,
			hsdusu:0.5,
			hsshenqi:0.5,
			hsyaoshui:0.5,
			hsqingyu:0.5,
			hsqizhou:0.5,
			hsjixie:0.5
		},
		card:{
			hsfashu_anyingjingxiang:{
				fullimage:true,
				type:'hsfashu',
				vanish:true,
				derivation:'hs_xukongzhiying',
				gainable:false
			},
			hsfashu_buwendingyibian:{
				enable(card,player){
					return get.cardCount('hsfashu_buwendingyibian',player)<player.hp;
				},
				fullimage:true,
				type:'hsfashu',
				vanish:true,
				derivation:'hs_siwangxianzhi',
				filterTarget:true,
				content(){
					'step 0'
					target.chooseCard('h',true,'重铸一张手牌',lib.filter.cardRecastable);
					'step 1'
					if(result.bool&&result.cards.length){
						target.recast(result.cards,null,(player,cards)=>{
							var type=get.type(cards[0],'trick'),name=cards[0].name,card2=get.cardPile(card=>get.type(card,'trick')==type&&card.name!=name);
							if(!card2) card2=get.cardPile(card=>get.type(card,'trick')==type);
							if(card2) player.gain(card2,'draw');
							else player.draw().log=false;
						});
						var clone=game.createCard(card);
						player.gain(clone,'gain2');
						clone.classList.add('glow');
						clone._destroy='yibian';
						player.addTempSkill('buwendingyibian_lose','phaseBegin');
						if(target.hasSkill('buwendingyibian_ai1')){
							target.addTempSkill('buwendingyibian_ai2');
						}
						else{
							target.addTempSkill('buwendingyibian_ai1');
						}
					}
				},
				ai:{
					wuxie(){
						return 0;
					},
					value(card){
						if(card._destroy) return 0;
						return 5;
					},
					useful:0,
					result:{
						target(player,target){
							if(target==player&&target.countCards('h',function(card){
								return card.name!='hsfashu_buwendingyibian'&&get.value(card)<=1;
							})){
								return 10;
							}
							var num=target.countCards('h');
							var num0=num;
							if(target==player) num--;
							if(target.hasSkill('buwendingyibian_ai1')) num/=2;
							if(target.hasSkill('buwendingyibian_ai2')) num/=2;
							if(num<0){
								if(num0>0) return 0.1;
								return 0;
							}
							return Math.sqrt(num);
						}
					},
					order:4
				}
			},
			hstianqi_dalian:{
				type:'equip',
				subtype:'equip1',
				distance:{attackFrom:-1},
				fullimage:true,
				vanish:true,
				destroy:'hstianqi',
				derivation:'hs_heifengqishi',
				skills:['hstianqi_dalian'],
				ai:{
					equipValue:10
				}
			},
			hstianqi_shali:{
				type:'equip',
				subtype:'equip2',
				distance:{attackFrom:-1},
				fullimage:true,
				vanish:true,
				destroy:'hstianqi',
				derivation:'hs_heifengqishi',
				skills:['hstianqi_shali'],
				ai:{
					equipValue:10
				}
			},
			hstianqi_nazigelin:{
				type:'equip',
				subtype:'equip4',
				distance:{globalFrom:-1},
				fullimage:true,
				vanish:true,
				destroy:'hstianqi',
				derivation:'hs_heifengqishi',
				onEquip(){
					player.changeHujia();
				},
				equipDelay:false,
				ai:{
					equipValue:10
				}
			},
			hstianqi_suolasi:{
				type:'equip',
				subtype:'equip3',
				distance:{globalTo:1},
				fullimage:true,
				vanish:true,
				destroy:'hstianqi',
				derivation:'hs_heifengqishi',
				onLose(){
					if(player.isDamaged()){
						player.logSkill('hstianqi_suolasi');
						player.recover();
					}
				},
				loseDelay:false,
				ai:{
					equipValue:10
				}
			},
			hsjixie_zhadan:{
				enable:true,
				fullimage:true,
				type:'hsjixie',
				vanish:true,
				derivation:'hs_pengpeng',
				filterTarget(card,player,target){
					return target==player;
				},
				modTarget:true,
				selectTarget:-1,
				cardcolor:'black',
				content(){
					var targets=target.getEnemies();
					if(targets.length){
						var target2=targets.randomGet();
						player.line(target2,'fire');
						target2.addExpose(0.2);
						target2.damage('fire');
					}
				},
				ai:{
					value:8,
					result:{
						target:1
					},
					order:4,
				}
			},
			hsqizhou_feng:{
				type:'hsqizhou',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_kalimosi',
				filterTarget(card,player,target){
					return target==player;
				},
				selectTarget:-1,
				content(){
					'step 0'
					event.list=target.getEnemies().sortBySeat();
					player.line(event.list,'thunder');
					'step 1'
					if(event.list.length){
						event.current=event.list.shift();
						event.current.addTempClass('target');
						var next=event.current.chooseToRespond({name:'sha'});
						next.ai=function(card){
							if(get.damageEffect(event.current,player,event.current,'thunder')>=0) return 0;
							if(player.hasSkillTag('notricksource')) return 0;
							if(event.current.hasSkillTag('notrick')) return 0;
							return 11-get.value(card);
						};
						next.autochoose=lib.filter.autoRespondSha;
					}
					else{
						event.finish();
					}
					'step 2'
					if(!result.bool){
						event.current.damage('thunder');
					}
					game.delayx(0.5);
					'step 3'
					event.goto(1);
				},
				ai:{
					order:8,
					useful:[5,1],
					value:8,
					result:{
						target:1,
					},
				}
			},
			hsqizhou_shui:{
				type:'hsqizhou',
				fullimage:true,
				vanish:true,
				enable(event,player){
					return player.isDamaged();
				},
				derivation:'hs_kalimosi',
				filterTarget(card,player,target){
					return target==player;
				},
				selectTarget:-1,
				content(){
					target.recover(2);
				},
				ai:{
					order:8,
					useful:[5,1],
					value:8,
					tag:{
						recover:1
					},
					result:{
						target:2,
					},
				}
			},
			hsqizhou_huo:{
				type:'hsqizhou',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_kalimosi',
				filterTarget:true,
				content(){
					target.damage('fire');
				},
				ai:{
					order:5,
					result:{
						target:-1,
					},
					useful:[5,1],
					value:8,
					tag:{
						damage:1,
						fireDamage:1,
						natureDamage:1,
					}
				}
			},
			hsqizhou_tu:{
				type:'hsqizhou',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_kalimosi',
				filterTarget(card,player,target){
					return target!=player
				},
				selectTarget:[1,Infinity],
				content(){
					target.changeHujia();
				},
				ai:{
					order:8,
					useful:[5,1],
					value:8,
					result:{
						target:1,
					},
				}
			},
			hsqingyu_feibiao:{
				type:'hsqingyu',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_aya',
				filterTarget(card,player,target){
					return target.countCards('he')>0;
				},
				content(){
					var cards=[];
					var hs=target.getCards('h');
					var es=target.getCards('e');
					if(hs.length) cards.push(hs.randomGet());
					if(es.length) cards.push(es.randomGet());
					target.discard(cards);
				},
				ai:{
					order:8,
					useful:3,
					value:6,
					result:{
						target(player,target){
							var num=0;
							if(target.countCards('h')) num--;
							if(target.countCards('e')) num--;
							return num;
						},
					},
				}
			},
			hsqingyu_zhanfang:{
				type:'hsqingyu',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_aya',
				filterTarget:true,
				content(){
					target.gainMaxHp();
					target.draw();
				},
				ai:{
					order:5,
					useful:3,
					value:4,
					result:{
						target(player,target){
							if(target.hp==target.maxHp){
								if(target.maxHp<3) return 2;
								if(target.maxHp==3) return 1.5;
								return 1.2;
							}
							return 1;
						},
					},
				}
			},
			hsqingyu_hufu:{
				type:'hsqingyu',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_aya',
				filterTarget:true,
				content(){
					target.changeHujia();
				},
				ai:{
					order:5,
					useful:3,
					value:6,
					result:{
						target(player,target){
							return 2/Math.max(1,Math.sqrt(target.hp));
						},
					},
				}
			},
			hsqingyu_shandian:{
				type:'hsqingyu',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_aya',
				filterTarget:true,
				content(){
					target.damage('thunder');
				},
				ai:{
					order:5,
					result:{
						target:-1,
					},
					useful:5,
					value:8,
					tag:{
						damage:1,
						thunderDamage:1,
						natureDamage:1,
					}
				}
			},
			hsqingyu_zhao:{
				type:'equip',
				subtype:'equip1',
				distance:{attackFrom:-1},
				fullimage:true,
				vanish:true,
				derivation:'hs_aya',
				onEquip(){
					player.draw();
				},
				ai:{
					order:9,
					useful:5,
					value:4
				}
			},
			hsdusu_xueji:{
				type:'hsdusu',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_xialikeer',
				filterTarget(card,player,target){
					return target.countCards('e')>0;
				},
				content(){
					target.discard(target.getCards('e').randomGets(2));
				},
				ai:{
					order:5,
					result:{
						target(player,target){
							if(target.hasSkillTag('noe')) return 0;
							if(target.countCards('e')>1) return -1.5;
							return -1;
						},
					},
					value:5,
				}
			},
			hsdusu_kuyecao:{
				type:'hsdusu',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_xialikeer',
				filterTarget(card,player,target){
					return !target.hasSkill('qianxing');
				},
				content(){
					target.tempHide();
				},
				ai:{
					order:2,
					result:{
						target(player,target){
							if(player!=target&&get.distance(player,target,'absolute')<=1) return 0;
							var num=1;
							if(target==player){
								num=1.5;
							}
							if(target.hp==1) return 2*num;
							if(target.hp==2&&target.countCards('h')<=2) return 1.2*num;
							return num;
						}
					},
					value:5,
				}
			},
			hsdusu_huangxuecao:{
				type:'hsdusu',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_xialikeer',
				filterTarget(card,player,target){
					return target==player;
				},
				selectTarget:-1,
				modTarget:true,
				content(){
					target.draw(2);
				},
				ai:{
					order:9,
					result:{
						target:1,
					},
					value:10,
				}
			},
			hsdusu_huoyanhua:{
				type:'hsdusu',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_xialikeer',
				range:{attack:1},
				filterTarget:true,
				content(){
					target.damage('fire');
				},
				ai:{
					order:5,
					result:{
						target:-1,
					},
					useful:5,
					value:8,
					tag:{
						damage:1,
						fireDamage:1,
						natureDamage:1,
					}
				}
			},
			hsdusu_shinancao:{
				type:'hsdusu',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_xialikeer',
				filterTarget(card,player,target){
					return !target.hasSkill('hsdusu_shinancao');
				},
				content(){
					target.addSkill('hsdusu_shinancao');
				},
				ai:{
					order:7,
					result:{
						target(player,target){
							if(target.hp>1){
								if(target.countCards('h')>2) return 1;
								return 0.5;
							}
							return 0.2;
						},
					},
					value:5,
				}
			},
			hsbaowu_cangbaotu:{
				type:'hsbaowu',
				fullimage:true,
				vanish:true,
				enable:true,
				gainable:false,
				derivation:'hs_yelise',
				filterTarget(card,player,target){
					return target==player;
				},
				selectTarget:-1,
				content(){
					target.addSkill('hsbaowu_cangbaotu');
					target.draw();
				},
				ai:{
					order:10,
					result:{
						player:10
					},
					useful:10,
					value:10,
				}
			},
			hsbaowu_huangjinyuanhou:{
				type:'hsbaowu',
				fullimage:true,
				vanish:true,
				enable:true,
				gainable:false,
				derivation:'hs_yelise',
				filterTarget(card,player,target){
					return target==player;
				},
				selectTarget:-1,
				content(){
					'step 0'
					var cards=target.getCards();
					if(cards.length){
						target.lose(cards)._triggered=null;
					}
					event.num=1+cards.length;
					'step 1'
					var cards=[];
					var list=[];
					if(lib.characterPack.hearth){
						for(var i=0;i<lib.cardPack.mode_derivation.length;i++){
							var name=lib.cardPack.mode_derivation[i];
							var info=lib.card[name];
							if(info.gainable==false) continue;
							if(lib.characterPack.hearth[info.derivation]){
								list.push(name);
							}
						}
					}
					if(!list.length){
						list=lib.inpile.slice(0);
					}
					if(list.length){
						for(var i=0;i<event.num;i++){
							cards.push(game.createCard(list.randomGet()));
						}
						target.directgain(cards);
					}
					target.tempHide();
				},
				ai:{
					order:10,
					result:{
						player(player){
							if(player.countCards('h')>1) return 1;
							if(player.hp==1) return 1;
							return 0;
						}
					},
					useful:10,
					value:10,
				}
			},
			hsshenqi_nengliangzhiguang:{
				type:'hsshenqi',
				fullimage:true,
				vanish:true,
				enable(card,player){
					return !player.isTurnedOver();
				},
				derivation:'hs_lafamu',
				filterTarget:true,
				content(){
					target.gainMaxHp();
					target.recover();
					target.draw(4);
				},
				contentAfter(){
					if(!player.isTurnedOver()){
						player.turnOver();
					}
				},
				ai:{
					order:5,
					result:{
						target(player,target){
							if(target.hp<=1) return 2;
							if(target.countCards('h')<target.hp||target.hp==2) return 1.5;
							return 1;
						}
					},
					useful:5,
					value:10,
				}
			},
			hsshenqi_kongbusangzhong:{
				type:'hsshenqi',
				fullimage:true,
				vanish:true,
				enable(card,player){
					return !player.isTurnedOver();
				},
				derivation:'hs_lafamu',
				filterTarget(card,player,target){
					return target!=player;
				},
				selectTarget:-1,
				content(){
					target.damage();
				},
				contentAfter(){
					if(!player.isTurnedOver()){
						player.turnOver();
					}
				},
				ai:{
					order:9,
					result:{
						target:-2
					},
					tag:{
						damage:1,
						multitarget:1,
						multineg:1,
					},
					useful:5,
					value:10,
				}
			},
			hsshenqi_morijingxiang:{
				type:'hsshenqi',
				fullimage:true,
				vanish:true,
				enable(card,player){
					return !player.isTurnedOver();
				},
				derivation:'hs_lafamu',
				filterTarget(card,player,target){
					return target!=player&&target.countCards('hej')>0;
				},
				selectTarget:-1,
				content(){
					if(target.countCards('hej')) player.gainPlayerCard(target,'hej',true);
				},
				contentAfter(){
					if(!player.isTurnedOver()){
						player.turnOver();
					}
				},
				ai:{
					order:9.5,
					result:{
						player:1
					},
					tag:{
						multitarget:1,
						multineg:1,
						loseCard:1,
						gain:1
					},
					useful:5,
					value:10,
				}
			},
			hsmengjing_feicuiyoulong:{
				type:'hsmengjing',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_ysera',
				filterTarget:true,
				content(){
					target.damage();
				},
				ai:{
					order:5,
					result:{
						target:-1
					},
					tag:{
						damage:1
					},
					useful:5,
					value:10,
				}
			},
			hsmengjing_suxing:{
				type:'hsmengjing',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_ysera',
				filterTarget(card,player,target){
					return player!=target;
				},
				selectTarget:-1,
				content(){
					target.loseHp();
					var he=target.getCards('he');
					if(he.length){
						target.discard(he.randomGets(2));
					}
				},
				ai:{
					result:{
						target:-1,
					},
					order:6,
					useful:5,
					value:10,
				}
			},
			hsmengjing_mengye:{
				type:'hsmengjing',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_ysera',
				filterTarget:true,
				content(){
					target.draw();
					target.addSkill('hsmengjing_mengye');
				},
				ai:{
					order:1,
					useful:5,
					value:10,
					result:{
						target(player,target){
							if(target.hasSkill('hsmengjing_mengye')) return 0.5;
							return -target.countCards('he');
						}
					}
				}
			},
			hsmengjing_mengjing:{
				type:'hsmengjing',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_ysera',
				filterTarget(card,player,target){
					return !target.hasJudge('lebu')||target.countCards('e')>0;
				},
				content(){
					'step 0'
					var es=target.getCards('e');
					if(es.length){
						target.gain(es,'gain2');
					}
					'step 1'
					if(!target.hasJudge('lebu')){
						target.addJudge(game.createCard('lebu'));
					}
				},
				ai:{
					order:2,
					useful:5,
					value:10,
					result:{
						target(player,target){
							var num=target.hp-target.countCards('he')-2;
							if(num>-1) return -1;
							if(target.hp<3) num--;
							if(target.hp<2) num--;
							if(target.hp<1) num--;
							return num;
						}
					}
				}
			},
			hsmengjing_huanxiaojiemei:{
				type:'hsmengjing',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_ysera',
				filterTarget(card,player,target){
					return target.hp<target.maxHp;
				},
				content(){
					target.recover();
				},
				ai:{
					order:6,
					value:10,
					useful:[7,4],
					result:{
						target(player,target){
							return get.recoverEffect(target,player,target);
						}
					}
				}
			},
			hszuzhou_nvwudeganguo:{
				type:'hszuzhou',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_hajiasha',
				filterTarget(card,player,target){
					return target.countCards('he');
				},
				content(){
					'step 0'
					target.chooseToDiscard('he',true);
					'step 1'
					if(!lib.characterPack.hearth){
						target.draw();
						return;
					}
					var list=[];
					for(var i=0;i<lib.cardPack.mode_derivation.length;i++){
						var name=lib.cardPack.mode_derivation[i];
						var info=lib.card[name];
						if(info.gainable==false||info.destroy) continue;
						if(lib.characterPack.hearth[info.derivation]){
							list.push(name);
						}
					}
					if(!list.length){
						target.draw();
					}
					else{
						target.gain(game.createCard(list.randomGet()),'draw');
					}
				},
				ai:{
					order:8,
					value:8,
					result:{
						target:1
					}
				}
			},
			hszuzhou_nvwudepingguo:{
				type:'hszuzhou',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_hajiasha',
				filterTarget:true,
				content(){
					target.gain([game.createCard('sha'),game.createCard('sha')],'gain2');
				},
				ai:{
					order:8.1,
					value:6,
					result:{
						target:1
					}
				}
			},
			hszuzhou_nvwudexuetu:{
				type:'hszuzhou',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_hajiasha',
				filterTarget(card,player,target){
					return !target.hasSkill('zhoujiang');
				},
				content(){
					if(!target.hasSkill('fengyin')){
						target.addTempSkill('fengyin',{player:'phaseAfter'});
					}
					target.addTempSkill('zhoujiang',{player:'phaseAfter'});
				},
				ai:{
					order:8.5,
					value:5,
					result:{
						target(player,target){
							if(target.hasSkill('fengyin')){
								return 1.5;
							}
							if(target.hasSkillTag('maixie')){
								if(target.countCards('h')<=1){
									return -0.1;
								}
							}
							else if(target.countCards('h')>1&&get.threaten(target)<=1.2){
								return 1;
							}
						}
					}
				}
			},
			hszuzhou_wushushike:{
				type:'hszuzhou',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_hajiasha',
				filterTarget:true,
				selectTarget:-1,
				multitarget:true,
				multiline:true,
				content(){
					'step 0'
					event.targets=game.filterPlayer().sortBySeat();
					'step 1'
					if(event.targets.length){
						event.current=event.targets.shift();
						var cards=event.current.getCards('h','shan');
						if(cards.length){
							event.current.lose(cards)._triggered=null;
						}
						event.num=cards.length;
					}
					else{
						event.finish();
					}
					'step 2'
					var cards=[];
					for(var i=0;i<event.num;i++){
						cards.push(game.createCard('sha'));
					}
					event.current.directgain(cards);
					event.goto(1);
				},
				ai:{
					order:4,
					value:6,
					result:{
						player(player){
							if(!player.hasSha()&&player.countCards('h','shan')&&game.hasPlayer(function(current){
								return player.canUse('sha',current,true,true)&&get.effect(current,{name:'sha'},player,player)>0;
							})){
								return 1;
							}
							return 0;
						}
					}
				}
			},
			hszuzhou_guhuo:{
				type:'hszuzhou',
				fullimage:true,
				vanish:true,
				enable:true,
				derivation:'hs_hajiasha',
				filterTarget(card,player,target){
					return target!=player&&target.countCards('he');
				},
				content(){
					'step 0'
					target.chooseCard('he',true);
					'step 1'
					if(result.bool){
						target.give(result.cards,player);
					}
				},
				ai:{
					order:8.6,
					value:8,
					result:{
						target(player,target){
							return -1/Math.sqrt(1+target.countCards('he'));
						}
					}
				}
			},
			tuteng1:{
				noname:true,
				fullimage:true,
				type:'hstuteng',
				derivation:'hs_sthrall',
				gainable:false
			},
			tuteng2:{
				noname:true,
				fullimage:true,
				type:'hstuteng',
				derivation:'hs_sthrall',
				gainable:false
			},
			tuteng3:{
				noname:true,
				fullimage:true,
				type:'hstuteng',
				derivation:'hs_sthrall',
				gainable:false
			},
			tuteng4:{
				noname:true,
				fullimage:true,
				type:'hstuteng',
				derivation:'hs_sthrall',
				gainable:false
			},
			tuteng5:{
				noname:true,
				fullimage:true,
				type:'hstuteng',
				derivation:'hs_sthrall',
				gainable:false
			},
			tuteng6:{
				noname:true,
				fullimage:true,
				type:'hstuteng',
				derivation:'hs_sthrall',
				gainable:false
			},
			tuteng7:{
				noname:true,
				fullimage:true,
				type:'hstuteng',
				derivation:'hs_sthrall',
				gainable:false
			},
			tuteng8:{
				noname:true,
				fullimage:true,
				type:'hstuteng',
				derivation:'hs_sthrall',
				gainable:false
			},
		},
		translate:{
			hs_alleria:'奥蕾莉亚',
			hs_magni:'麦格尼',
			hs_medivh:'麦迪文',
			hs_jaina:'吉安娜',
			hs_lrexxar:'雷克萨',
			hs_wuther:'乌瑟尔',
			hs_jgarrosh:'加尔鲁什',
			hs_malfurion:'玛法里奥',
			hs_guldan:'古尔丹',
			hs_anduin:'安度因',
			hs_sthrall:'萨尔',
			hs_waleera:'瓦莉拉',
			hs_liadrin:'莉亚德琳',
			hs_morgl:'摩戈尔',

			hs_neptulon:'耐普图隆',
			hs_wvelen:'维纶',
			hs_antonidas:'安东尼达斯',
			hs_alakir:'奥拉基尔',
			hs_zhouzhuo:'周卓',
			hs_yngvar:'伊戈瓦尔',
			hs_bchillmaw:'冰喉',
			hs_malorne:'玛洛恩',
			hs_xsylvanas:'希尔瓦娜斯',
			hs_siwangzhiyi:'死亡之翼',
			hs_malygos:'玛里苟斯',
			hs_xuefashi:'血法师',
			hs_ysera:'伊瑟拉',
			hs_alextrasza:'阿莱克斯塔',
			hs_trueheart:'图哈特',
			hs_nozdormu:'诺兹多姆',
			hs_loatheb:'洛欧塞布',
			hs_jiaziruila:'加兹瑞拉',
			hs_sainaliusi:'塞纳留斯',
			hs_bolvar:'伯瓦尔',
			hs_lrhonin:'罗宁',
			hs_fuding:'弗丁',
			hs_aedwin:'艾德温',
			hs_lafamu:'拉法姆',
			hs_yelise:'伊莉斯',
			hs_lreno:'雷诺',
			hs_finley:'芬利',
			hs_brann:'布莱恩',
			hs_kcthun:'克苏恩',
			hs_anomalus:'阿诺玛鲁斯',
			hs_blingtron:'布林顿',
			hs_fandral:'范达尔',
			hs_hallazeal:'海纳泽尔',
			hs_enzoth:'恩佐斯',
			hs_walian:'瓦里安',
			hs_pengpeng:'砰砰博士',
			hs_aya:'艾雅',
			hs_pyros:'派洛斯',
			hs_jiawodun:'嘉沃顿',
			hs_laila:'莱拉',
			hs_selajin:'瑟拉金',
			hs_bannabusi:'班纳布斯',
			hs_amala:'阿玛拉',
			hs_nuogefu:'诺格弗',
			hs_kazhakusi:'卡扎库斯',
			hs_lazi:'拉兹',
			hs_shaku:'沙库尔',
			hs_laxiao:'拉希奥',
			hs_yashaji:'亚煞极',
			hs_khadgar:'卡德加',
			hs_tyrande:'泰兰德',
			hs_fenjie:'芬杰',
			hs_kalimosi:'卡利莫斯',
			hs_yogg:'尤格萨隆',
			hs_xialikeer:'夏克里尔',
			hs_wolazi:'沃拉兹',
			hs_tanghangu:'唐·汉古',
			hs_barnes:'巴内斯',
			hs_kchromaggus:'克洛玛古斯',
			hs_kaituozhe:'开拓者',

			hs_yelinlonghou:'夜鳞龙后',
			hs_yelinchulong:'雏龙',
			hs_ronghejuren:'熔核巨人',
			hs_shanlingjuren:'山岭巨人',
			hs_mijiaojisi:'秘教祭司',
			hs_huzhixiannv:'湖之仙女',
			hs_totemic:'图腾师',
			hs_bilanyoulong:'碧蓝幼龙',
			hs_zhishigushu:'知识古树',
			hs_zhanzhenggushu:'战争古树',
			hs_jinglinglong:'精灵龙',
			hs_sapphiron:'萨菲隆',
			hs_xuanzhuanjijia:'旋转机甲',
			hs_ruanniguai:'软泥怪',
			hs_hudunren:'护盾机甲',
			hs_nate:'纳特',
			hs_shifazhe:'嗜法者',
			hs_xiangyaqishi:'象牙骑士',
			hs_wujiyuansu:'无羁元素',
			hs_mojinbaozi:'魔晶孢子',
			hs_shuiwenxuejia:'水文学家',
			hs_shizugui:'始祖龟',
			hs_hemite:'赫米特',
			hs_yinggencao:'萤根草',
			hs_zhihuanhua:'致幻花',
			hs_shirencao:'食人草',
			hs_fachaotuteng:'法潮图腾',
			hs_huolituteng:'活力图腾',
			hs_manyututeng:'蛮鱼图腾',
			hs_tgolem:'图腾魔像',
			hs_heifengqishi:'黑锋骑士',
			hs_yuhuozhe:'浴火者',
			hs_wuyaowang:'巫妖王',
			hs_aerfusi:'阿尔福斯',
			hs_baiguyoulong:'白骨幼龙',
			hs_yangyanwageli:'阳焰瓦格里',
			hs_aiqinvyao:'哀泣女妖',
			hs_ashamoer:'阿莎摩尔',
			hs_fengjianhuanfengzhe:'风剪唤风者',
			hs_taisi:'苔丝',
			hs_hajiasha:'哈加莎',
			hs_tuoqi:'托奇',
			hs_siwangxianzhi:'死亡先知',
			hs_xukongzhiying:'虚空之影',
			hs_duyaxinshi:'渡鸦信使',

			hshuanyu:'幻羽',
			hshuanyu_info:'每当你受到一次伤害，你获得发现一张炉石衍生牌。',
			hsfashu:'法术',
			hsfashu_anyingjingxiang:'暗影镜像',
			hsfashu_anyingjingxiang_info:'当你使用或打出一张牌后，暗影镜像变为该牌的复制。',
			hsfashu_buwendingyibian:'不稳定异变',
			hsfashu_buwendingyibian_info:'出牌阶段对一名角色使用，目标将一张手牌重铸为同类别的牌，本回合可重复使用此牌，最多使用X次，X为当前体力值。',
			hualing:'化灵',
			hualing_info:'每三轮限一次，你可以选择一名其他角色，获得其一项技能，然后将其随机变形为一名强度高一级的武将。',
			yibian:'异变',
			yibian_info:'锁定技，出牌阶段开始时，若你没有不稳定异变，则将一张不稳定异变置于你的手牌。',
			wxuying:'虚影',
			wxuying_info:'锁定技，准备阶段，你移去手牌中的暗影镜像，然后获得一张暗影镜像（当你使用或打出一张牌后，暗影镜像变为该牌的复制）；当你回合内使用暗影镜像时，你摸一张牌；当你回合外使用暗影镜像时，你获得潜行直到下一回合开始。',
			zhoujiang:'咒降',
			zhoujiang_info:'锁定技，每当你使用一张普通锦囊牌，你将一张随机“诅咒”牌置于你的手牌。',
			muyin:'暮隐',
			muyin_info:'锁定技，每当你失去最后一张手牌，你获得潜行直到下一回合开始。',
			tqchuanyue:'穿越',
			tqchuanyue_info:'锁定技，准备阶段开始时，你随机选择一个被削弱过的炉石技能，获得其未削弱的版本，替换上一个以此法获得的技能。',
			// hsxiujian:'袖箭',
			// hsxiujian_info:'锁定技，在你对一名敌方角色使用一张锦囊牌后，你视为对其使用一张杀。',
			// hsyingzong:'影踪',
			// hsyingzong_info:'',
			hsxingyi:'星移',
			hsxingyi_info:'锁定技，每当一名敌方角色于回合内使用主动技能，你获得此技能直到下一回合结束。',

			hshuanling:'幻灵',
			hshuanling_bg:'灵',
			hshuanling_info:'结束阶段，你可以弃置至多X张牌（X为你装备区内的牌数且至少为1）并摸等量的牌，每弃置一张牌，你随机使用一张本局敌方角色使用过的单目标非转化普通锦囊牌，随机指定一个具有正收益的角色为目标。',
			// hshuanling_info:'锁定技，当你于回合内使用首张指定其他角色为惟一目标的锦囊牌后，你视为对其随机使用一张锦囊牌（此牌对你有正面效果）。',
			// hshuanling_info:'每当你使用一张基本牌或普通锦囊牌，你可以弃置任意张牌令其增加或减少等量的目标。',
			huanfeng:'唤风',
			huanfeng_info:'锁定技，准备阶段，若你有4个图腾，你失去所有图腾，然后获得并召唤随从奥拉基尔。',
			asyouzhang:'幽瘴',
			asyouzhang_info:'结束阶段，若你的手牌中没有基本牌/锦囊牌/装备牌，你可以获得牌堆顶的一张基本牌/锦囊牌/装备牌，并可以立即使用。',
			ylyuchu:'育雏',
			ylyuchu_info:'锁定技，每当你回复1点体力，你获得一只雏龙随从（不超过3只）；结束阶段，你每有一只雏龙，便随机选择一名其他角色，在该角色的下个回合开始前你切换至该雏龙，然后在此回合结束后进行一个额外回合并切换回本体。',
			nsaiqi:'哀泣',
			nsaiqi_info:'锁定技，每当你使用一张牌，你移除牌堆顶的三张牌；你的手牌上限始终+1。',
			nsbeiming:'悲鸣',
			nsbeiming_info:'锁定技，当你移除的牌不少于9张时，你摸一张牌，然后将移除的牌以任意顺序置于牌堆顶；当被移除过的牌在牌堆顶时（洗牌后重置），你的不能发动【哀泣】移除牌。',
			hstianqi_dalian:'达里安',
			hstianqi_dalian_info:'每当你造成一次伤害，你回复等量的体力。',
			hstianqi_shali:'莎莉',
			hstianqi_shali_info:'每当你回复体力，你获得等量的护甲。',
			hstianqi_nazigelin:'纳兹戈林',
			hstianqi_nazigelin_info:'当你装备此牌时，你获得1点护甲。',
			hstianqi_suolasi:'索拉斯',
			hstianqi_suolasi_info:'当你失去此牌时，你回复1点体力。',
			hschaoxi:'潮袭',
			hschaoxi_info:'锁定技，每当你造成一次伤害，你获得两张随机鱼人牌。',
			hsnitai:'拟态',
			hsnitai_info:'锁定技，出牌阶段开始时，你获得一张随机炉石角色的技能牌。',
			hstianqi:'天启',
			hstianqi_info:'出牌阶段限一次，你可以选择一项：弃置一张手牌并随机装备一件天启骑士（不能替换现有装备），或弃置一张装备区内的牌并摸两张牌；当你以此法弃置天启骑士时，若你武将牌上没有对应的天启骑士，你将其置于你的武将牌上；准备阶段，若你的武将牌上有4张天启骑士，你获得游戏胜利。',
			hspuzhao:'普照',
			hspuzhao_info:'出牌阶段限一次，你可以弃置一张红桃牌，然后令至多三名随机友方角色各摸一张牌（若你无其他队友，改为摸两张牌）。',
			hsyanxin:'炎心',
			hsyanxin_info:'锁定技，在你摸牌时，若牌堆中有红色牌，你摸到的首张牌必为红色。',
			ysjqisha:'七煞',
			ysjqisha_ju:'惧之煞',
			ysjqisha_kuang:'狂之煞',
			ysjqisha_nu:'怒之煞',
			ysjqisha_yi:'疑之煞',
			ysjqisha_wang:'惘之煞',
			ysjqisha_hen:'恨之煞',
			ysjqisha_ao:'傲之煞',
			ysjqisha_info:'锁定技，每当你造成或受到伤害，你令对方随机获得一种消极状态直到下一回合结束。',
			zhaochao:'招潮',
			zhaochao_info:'锁定技，结束阶段，你视为对一名随机敌人使用一张杀；若此杀被闪避，你视为对另一名随机敌人使用一张杀。',
			hllingxi:'灵息',
			hllingxi_info:'出牌阶段，你可以令一名已受伤的其他角色弃置两张牌并回复1点体力（同阶段对一名角色限用一次）；结束阶段，你可以回复1点体力。',
			xiyong:'汐涌',
			xiyong_info:'结束阶段，你可以摸一张牌并可以使用之，若你使用了此牌，你再摸一张牌。',
			hsjixie:'机械',
			hsjixie_zhadan:'炸弹机器人',
			hsjixie_zhadan_pop:'炸弹',
			hsjixie_zhadan_info:'出牌阶段对自己使用，对一名随机敌人造成1点火属性伤害。',
			yindan:'引弹',
			yindan_info:'出牌阶段限一次，你可以弃置一张黑桃牌并失去1点体力，然后获得两张炸弹机器人。',
			huanjue:'幻觉',
			huanjue_info:'每当你使用一张牌，若此牌指定了惟一目标，你可以发现一张牌，然后可以代替此牌结算。',
			oldhuanjue:'幻觉',
			oldhuanjue_info:'每回合限一次，当你成为一名其他角色的卡牌惟一目标时，你可以发现一张牌代替此牌。',
			zhziwu:'紫雾',
			zhziwu_info:'每当你于回合外失去牌，你可以令当前回合角色不能使用杀直到回合结束。',
			huanjue_info_old:'每名角色的回合限一次，当你使用卡牌指定其他角色为惟一目标，或当其他角色使用卡牌指定你为惟一目标时，你可以发现一张牌代替此牌，然后该牌的使用者在结算后摸一张牌。',
			yinzong:'影踪',
			yinzong_info:'锁定技，每当你失去装备区内的牌，你获得一张闪。',
			tansuo:'探索',
			tansuo_info:'出牌阶段限一次，你可以弃置一张牌，然后发现一张炉石衍生牌。',
			srjici:'棘刺',
			srjici_info:'锁定技，每当你造成一次伤害，你摸一张牌，受伤害角色随机弃置一张牌。',
			lieqi:'猎奇',
			lieqi_info:'准备和结束阶段，你可以指定一名角色，从一张该角色手牌与另外两张随机牌中猜测哪张为该角色手牌，若猜中，你获得一张该牌的复制（同一回合不能指定相同角色）。',
			azaowu:'造物',
			azaowu_backup:'造物',
			azaowu_info:'出牌阶段限一次，你可以将一张基本牌当作任意一张基本牌使用。',
			shouwang:'守望',
			shouwang2:'守望',
			shouwang_info:'每名角色每局限一次，当一名角色进入濒死状态时，你可以令其回复1点体力并获得1点护甲。',
			shouwang_info_alter:'每名角色每局限一次，当一名角色进入濒死状态时，你可以令其回复1点体力。',
			qingtian:'擎天',
			qingtian_info:'锁定技，若你的体力值为全场最多，你受到的伤害始终+1。',
			qianfu:'潜伏',
			qianfu2:'潜伏',
			qianfu2_bg:'伏',
			qianfu_info:'锁定技，在你死亡前，若你没有进入潜伏状态，你弃置所有牌并进入潜伏状态；当你体力值回复到3（或体力上限）时，你解除潜伏状态并摸三张牌。',
			shimo:'尸魔',
			shimo_info:'锁定技，距离你为1的角色受到伤害时，你回复1点体力，若你没受伤，改为摸一张牌。',
			lieyang:'裂阳',
			lieyang_info:'锁定技，每当你于回合内使用一张锦囊牌，你获得一张随机锦囊牌；当你发动三次此技能后，你本回合不能再使用锦囊牌。',
			zhuilie:'追猎',
			zhuilie_info:'准备阶段，你可以弃置一张牌，然后将牌堆顶六张牌中的基本牌移至弃牌堆；若移入弃牌堆的牌超过三张，你摸一张牌。',
			szbianshen:'变身',
			szbianshen_info:'限定技，回合开始时，若游戏轮数不少于3，你可以随机观看5张体力上限不小于5的武将牌，将武将牌替换为其中一张。',
			kekao:'科考',
			kekao_info:'结束阶段，你可以发现一张延时锦囊牌。',
			jinhua:'进化',
			jinhua_info:'锁定技，每当你以自己为目标使用一张非转化的锦囊牌，你发现一个技能并获得之。',
			hsqizhou:'祈咒',
			hsqizhou_feng:'风之祈咒',
			hsqizhou_feng_info:'出牌阶段对自己使用，令所有目标的敌人打出一张杀或受到1点雷属性伤害。',
			hsqizhou_shui:'水之祈咒',
			hsqizhou_shui_info:'出牌阶段对自己使用，回复2点体力。',
			hsqizhou_huo:'火之祈咒',
			hsqizhou_huo_info:'出牌阶段对任意角色使用，令目标受到1点火属性伤害。',
			hsqizhou_tu:'土之祈咒',
			hsqizhou_tu_info:'出牌阶段对任意其他角色使用，令目标获得1点护甲。',
			kqizhou:'祈咒',
			kqizhou_info:'准备阶段，若你于上回合使用过锦囊牌，则可以获得一张元素祈咒。',
			jingcu:'晶簇',
			jingcu_info:'出牌阶段，你可以减少1点体力上限并摸两张牌。',
			shengzhang:'生长',
			shengzhang_info:'锁定技，若你于弃牌阶段弃置了牌，你增加1点体力上限。',
			pyuhuo:'浴火',
			pyuhuo_info:'锁定技，在你首次进入濒死状态时，你弃置所有牌、重置武将牌、将体力和体力上限变为4并摸四张牌；在你第二次进入濒死状态时，你弃置所有牌、重置武将牌、将体力和体力上限变为6并摸六张牌。',
			mengye:'梦魇',
			mengye_info:'结束阶段，你可以选择一名有手牌的角色将其一张随机的非毒手牌转化为毒，然后令其获得1点护甲。',
			mengye_old:'梦魇',
			mengye_old2:'梦魇',
			mengye_old_info:'回合结束后，你可以翻面并指定一名的非主公角色，由你控制其进行一个额外的回合。在此回合中，你的本体不参与游戏。',
			fuhua:'腐化',
			fuhua2:'腐化',
			fuhua_info:'出牌阶段，你可以将一张毒交给一名没有魔血技能的其他角色，该角色选择一项：1. 获得技能魔血，此后每个结束阶段需交给你一张手牌；2. 视为你对其使用一张决斗。',
			moxie:'魔血',
			moxie_info:'锁定技，当你因【毒】失去体力时，你改为摸两张牌；结束阶段，你将一张随机手牌转化为毒。',
			gfuhun:'附魂',
			gfuhun_info:'结束阶段，若你未翻面，你可以和一名其他角色拼点，若你赢，你将武将牌翻至背面，该角色进入混乱状态直到下一回合结束。',
			hlongyi:'龙裔',
			hlongyi_info:'锁定技，你的黑色牌不占用手牌上限。',
			zhongji:'重击',
			zhongji_info:'每当你即将造成伤害，可弃置一张黑色手牌令伤害+1。',
			fuwen:'符文',
			fuwen_info:'若你弃牌阶段弃置了锦囊牌，你可以获得1点护甲。',
			jinzhou:'禁咒',
			jinzhou_info:'结束阶段，若你手牌中有黑桃牌，你可以令一名其他角色的非锁定技失效直到其下一回合结束。',
			midian:'秘典',
			midian_info:'出牌阶段限一次，你可以弃置一张锦囊牌，然后随机获得三张锦囊牌。',
			yuelu:'月露',
			yuelu_info:'在一名角色的濒死阶段，你可以弃置一张黑色牌令其回复1点体力并获得1点护甲。',
			yuelu_info_alter:'在一名角色的濒死阶段，你可以弃置一张黑色牌令其回复1点体力。',
			xingluo:'星落',
			xingluo_info:'准备阶段，你可以令任意名手牌数多于你的角色各弃置一张手牌，然后你可以从弃置的牌中选择一张加入手牌。',
			yushou:'御兽',
			yushou_info:'出牌阶段，你可以弃置一张牌并召唤一个随机的野兽宠物，回合开始阶段，你随机失去一个宠物。',
			yushou_misha:'米莎',
			yushou_misha_info:'每当你受到一次伤害，你获得1点护甲。',
			yushou_huofu:'霍弗',
			yushou_huofu_info:'你可以将一张黑色牌当作决斗使用。',
			yushou_leiouke:'雷欧克',
			yushou_leiouke_info:'你每回合造成的首次伤害+1。',
			hsqingyu_hufu:'青玉护符',
			hsqingyu_hufu_info:'令一名角色获得1点护甲。',
			hsqingyu_zhao:'青玉之爪',
			hsqingyu_zhao_info:'当你装备此装备时，摸一张牌。',
			hsqingyu_feibiao:'青玉飞镖',
			hsqingyu_feibiao_info:'弃置一名角色的一张随机手牌和一张随机装备牌。',
			hsqingyu_shandian:'青玉闪电',
			hsqingyu_shandian_info:'对一名角色造成1点雷电伤害。',
			hsqingyu_zhanfang:'青玉绽放',
			hsqingyu_zhanfang_info:'令一名角色增加1点体力上限并摸一张牌。',
			ayuling:'玉灵',
			ayuling_info:'每当你受到一次伤害，你可以获得一张随机青玉牌。',
			qingzun:'青樽',
			qingzun_info:'本局对战中，每当你使用一张青玉牌，你的手牌上限+1；当你累计使用两张青玉牌后，你可以于准备阶段摸一张牌；当你累计使用六张青玉牌后，你可以于结束阶段摸一张牌。',
			qingzun_info_alter:'本局对战中，每当你使用一张青玉牌，你的手牌上限+1；当你累计使用三张青玉牌后，你可以于准备阶段摸一张牌；当你累计使用九张青玉牌后，你可以于结束阶段摸一张牌。',
			lianjin:'炼金',
			lianjin_info:'出牌阶段限一次，你可以弃置一张牌并获得一张由三张随机牌组成的药水；当你因弃置而失去药水牌时，你随机获得药水的组成卡牌之一。',
			shouji:'收集',
			shouji_info:'每当你使用一张杀，你可以获得一张目标随机手牌的复制；每当你的杀被闪避，你可以获得一张目标随机非特殊装备牌的复制；每回合限各限一次。',
			hsguimou:'鬼谋',
			hsguimou_info:'每当你受到一次伤害，你可以获得伤害来源的一张手牌，若此牌是黑色，你展示此牌并重复此过程。',
			yingxi:'影袭',
			yingxi_info:'结束阶段，若你本回合未造成伤害，你可以将一张黑色牌当作杀对任意一名角色使用，若目标未受到伤害，此杀不可闪避。',
			peiyu:'培育',
			peiyu_info:'准备阶段，你可以令一名没有图腾的角色获得一个随机图腾直到其首次受到伤害。',
			peiyu_old_info:'出牌阶段，你可以弃置一张牌令一名没有图腾的角色获得一个随机图腾，或令一名有图腾的角色替换一个图腾；你死亡时，其他角色失去以此法获得的图腾。',
			wzhanyi:'战意',
			wzhanyi_info:'你可以跳过出牌阶段，改为摸三张牌并展示之，将摸到的装备牌置于装备区，然后可以使用手牌中的杀。',
			shengteng:'升腾',
			shengteng_info:'锁定技，每当你使用锦囊牌造成伤害，你增加1点体力上限并回复1点体力。',
			yuansu:'寂灭',
			yuansu_info:'出牌阶段限一次，若你已损失的体力值不少于3，你可以将体力上限降至与体力值相同，视为使用一张元素毁灭。',
			nuyan:'怒焰',
			nuyan2:'怒焰',
			nuyan_backup:'怒焰',
			nuyan_info:'出牌阶段限一次，你可以将一张红色牌当作任意一张能造成伤害的牌使用（不得是你本局以此法使用过的牌）。',
			nuyan2_info:'出牌阶段限三次，你可以失去1点体力，视为使用任意一张能造成伤害的牌”。',
			chouhuo:'仇火',
			chouhuo_info:'觉醒技，出牌阶段开始时，若你的怒焰技能已将可用的牌用完，你失去1点体力上限，获得2点护甲，然后将怒焰的描述改为“出牌阶段限三次，你可以失去1点体力，视为使用任意一张能造成伤害的牌”。',
			hsdusu:'毒素',
			hsdusu_xueji:'血蓟',
			hsdusu_xueji_info:'随机弃置一名角色的2张装备牌。',
			hsdusu_shinancao:'石楠草',
			hsdusu_shinancao_info:'令一名角色下一次造成的伤害+1。',
			hsdusu_kuyecao:'枯叶草',
			hsdusu_kuyecao_info:'令一名角色获得技能潜行，直到其下一回合开始。',
			hsdusu_huoyanhua:'火焰花',
			hsdusu_huoyanhua_info:'对攻击范围内的一名角色造成1点火焰伤害。',
			hsdusu_huangxuecao:'皇血草',
			hsdusu_huangxuecao_info:'摸两张牌。',
			duxin:'毒心',
			duxin_info:'准备阶段和结束阶段，若你的手中没有毒素牌，你可以获得一张随机毒素牌。',
			oldduxin:'毒心',
			oldduxin_info:'准备阶段和结束阶段，你可以获得一张随机毒素牌。',
			hstuteng:'图腾',
			kuangluan:'狂乱',
			kuangluan2:'狂乱',
			// kuangluan_info:'锁定技，每当你于回合内使用一张普通锦囊牌，便于出牌阶段结束时随机使用一张普通锦囊牌（随机指定目标）。',
			kuangluan_info:'锁定技，每当一名其他角色对你造成伤害，该角色进入混乱状态直到当前回合结束。',
			zengli:'赠礼',
			zengli_info:'出牌阶段限一次，你指定一名其他角色与你各装备一把武器。',
			xiubu:'修补',
			xiubu_info:'每当你装备一把未强化的武器，你可以获得数量等同于武器攻击范围的随机零件。',
			mobao:'魔爆',
			mobao_info:'出牌阶段限一次，你可以弃置至多三张黑色牌，然后对所有于上轮对你造成过伤害的角色造成等同于你弃牌数的雷电伤害。',
			xianji:'献祭',
			xianji2:'献祭',
			xianji3:'献祭',
			xianji_info:'其他角色可以在其结束阶段弃置1~2张手牌并令你摸等量的牌，若如此做，直到其下一回合结束，每当你使用卡牌指定其为目标时，其摸一张牌。',
			xueren:'血刃',
			xueren_info:'每当你使用杀造成伤害，你可以令受伤害角色与你各失去1点体力，然后你摸两张牌。',
			maoxian:'奇旅',
			maoxian2:'奇旅',
			maoxian_info:'出牌阶段限两次，你可以发现一个技能并获得之（替换此前发现的技能）。',
			tanmi:'探秘',
			tanmi_info:'在一名其他角色的结束阶段，若你没有手牌，你可以摸两张牌并可以使用两张牌。',
			yiwen:'轶闻',
			yiwen_info:'锁定技，每当其他角色于回合内首次使用非特殊卡牌指定你为惟一目标，你获得一张此牌的复制。',
			tanbao_old:'探宝',
			tanbao_old_info:'出牌阶段限一次，你可以弃置三张牌，然后展示牌堆顶的三张牌，然后获得其中任意张类别不同的牌；若三张牌类别均不相同，你回复全部体力值。',
			qianghuax:'强化',
			qianghuax_info:'出牌阶段限一次，你可以弃置任意张不同类别的牌，然后展示并获得与弃置的牌类别相同且价值更高的牌。',
			zhuizong:'追踪',
			zhuizong_info:'出牌阶段限一次，你可以弃置任意张牌，观看牌堆顶的等同于弃牌数四倍的牌，然后获得其中的一张牌。',
			xunbao:'寻宝',
			xunbao2:'寻宝',
			xunbao_info:'准备阶段，若你的武将牌上没有藏宝图，你可以将一张藏宝图置于你的武将牌上；若你的武将牌上有藏宝图，你可以弃置一张与藏宝图点数相同的牌并获得此藏宝图。',
			xieneng:'邪能',
			xieneng_info:'结束阶段，你可以选择一张神器牌并获得之。',
			fbeifa:'北伐',
			fbeifa_info:'每当你失去最后一张手牌，你可以视为使用一张无视距离的杀，若此杀造成伤害，你摸一张牌，每回合最多发动3次。',
			oldfbeifa:'北伐',
			oldfbeifa_info:'每当你失去最后一张手牌，你可以视为使用一张无视距离的杀，若此杀造成伤害，你摸一张牌。',
			yufa:'驭法',
			yufa_info:'在任意一名其他角色的结束阶段，若你于此回合内受过其伤害，你可以将一张传送门交给除此角色外的任意一名角色。',
			bingyan:'冰焰',
			bingyan_info:'出牌阶段限一次，你可以将一张红色牌当作炽羽袭，或将一张黑色牌当作惊雷闪使用。',
			hsshenqi:'神器',
			hsshenqi_morijingxiang:'末日镜像',
			hsshenqi_morijingxiang_info:'限武将牌正面朝上时使用，从所有其他角色的区域内各获得一张牌；使用后将武将牌翻至背面。',
			hsshenqi_kongbusangzhong:'恐怖丧钟',
			hsshenqi_kongbusangzhong_info:'限武将牌正面朝上时使用，对所有其他角色各造成1点伤害；使用后将武将牌翻至背面。',
			hsshenqi_nengliangzhiguang:'能量之光',
			hsshenqi_nengliangzhiguang_info:'限武将牌正面朝上时使用，令一名角色增加1点体力上限，回复1点体力，并摸四张牌；使用后将武将牌翻至背面。',
			hsbaowu:'宝物',
			hsbaowu_huangjinyuanhou:'黄金猿猴',
			hsbaowu_huangjinyuanhou_info:'将你的手牌（含此张）替换为随机炉石衍生牌，并获得潜行直到下一回合开始。',
			hsbaowu_cangbaotu:'藏宝图',
			hsbaowu_cangbaotu_info:'结束阶段，将一张黄金猿猴置入你的手牌；摸一张牌。',
			hsyaoshui:'药水',
			hsqingyu:'青玉',

			lianzhan:'连斩',
			lianzhan_info:'每当你造成一次伤害，若此伤害是你本回合第一次造成伤害，你摸两张牌；否则你增加1点体力上限并回复1点体力。',
			shifa:'魔瘾',
			shifa_info:'锁定技，每当你于回合内使用一张非转化的普通锦囊牌，你摸一张牌（每回合最多发动3次）；出牌阶段开始时，你令你与一名随机敌人各获得一张随机普通锦囊牌。',
			oldshifa:'魔瘾',
			oldshifa_info:'锁定技，每当你于回合内使用一张非转化的普通锦囊牌，你摸一张牌；出牌阶段开始时，你令你与一名随机敌人各获得一张随机普通锦囊牌。',
			yuanzheng:'远征',
			yuanzheng_info:'每当你对距离1以外的角色使用一张牌，你可以弃置目标区域内的一张牌。',
			bzhuiji:'追击',
			bzhuiji_info:'每当一名角色死亡，你可以摸两张牌，并视为对杀死该角色的人使用一张决斗。',
			byuhuo:'浴火',
			byuhuo2:'浴火',
			byuhuo_info:'觉醒技，当你进入濒死状态时，你须将体力和体力上限变为2，并将武将牌翻至背面；在你的下一准备阶段，你对所有其他角色造成2点火焰伤害，在此之前，你不能成为其他角色的卡牌的目标。',
			yulu:'雨露',
			yulu_info:'出牌阶段限一次，你可以指定任意名角色各摸一张牌，然后各弃置区域内的一张牌。',
			oldyulu:'雨露',
			oldyulu_info:'出牌阶段限一次，你可以指定任意名角色各摸两张牌，然后各弃置区域内的两张牌。',
			duzhang:'毒瘴',
			duzhang2:'毒瘴',
			duzhang_info:'结束阶段，若你于本回合内未使用过锦囊牌，你可以指定一名其他角色令其下个回合无法使用锦囊牌。',
			hannu:'寒怒',
			hannu_info:'锁定技，每当你受到一次伤害，你将手牌数翻倍；若你的手牌数因此超过10张，你随机弃置若干张手牌直到手牌数等于你当前的体力值。',
			chuidiao:'垂钓',
			chuidiao_info:'锁定技，结束阶段，你随机摸0~2张牌。',
			fushi:'缚誓',
			fushi_info:'出牌阶段限一次，你可以令一名已受伤角色失去1点体力上限并回复1点体力。',
			oldfushi:'缚誓',
			oldfushi_info:'出牌阶段，你可以令一名已受伤角色失去1点体力上限并回复1点体力。',
			hhudun:'护盾',
			hhudun_info:'锁定技，在每名角色的准备阶段，若你没有护甲，你获得1点护甲；每当你的护甲抵消一次伤害，你摸一张牌。',
			fenlie:'分裂',
			fenlie_info:'锁定技，每当你于摸牌阶段外获得非特殊卡牌，你获得一张此牌的复制，每回合最多发动两次。',
			oldfenlie:'分裂',
			oldfenlie_info:'锁定技，每当你于摸牌阶段外获得非特殊卡牌，你获得一张此牌的复制。',
			nianfu:'粘附',
			nianfu_info:'锁定技，每当你造成或受到伤害，你随机获得对方装备区内的一张牌。',
			xiaorong:'消融',
			xiaorong_info:'锁定技，你的装备牌不占用手牌上限；结束阶段，你将手牌中的每张装备牌转化为两张随机基本牌，每转化一张装备牌便回复1点体力。',
			shixu:'时序',
			shixu_info:'锁定技，所有角色于出牌阶段每消耗3秒，便须于结束阶段弃置一张牌。',
			qianghua:'绝手',
			qianghua_info:'出牌阶段内，你可以令一张你使用的基本牌或普通锦囊牌额外结算一次，每回合限一次。',
			jixuan:'疾旋',
			jixuan_info:'锁定技，回合结束后，你摸一张牌进行一个额外的回合。',
			biri:'蔽日',
			biri_info:'每当距离你1以内的一名其他角色成为杀的惟一目标时，若杀的使用者不是你，你可以弃置一张闪取消之。',
			stuxi:'吐息',
			stuxi2:'吐息',
			stuxi2_bg:'息',
			stuxi_info:'锁定技，结束阶段，你令一名随机敌人下一个摸牌阶段摸牌数-1。',
			bingdong:'冰冻',
			bingdong_info:'锁定技，你在一个回合内首次造成伤害后，获得一个冰冻零件。',
			ronghuo:'熔火',
			ronghuo_info:'锁定技，你的普通杀均视为火杀。',
			luoshi:'落石',
			luoshi_info:'锁定技，每当你受到一次伤害，你与伤害来源各随机弃置一张牌。',
			moyao:'魔曜',
			moyao_info:'锁定技，你不能成为其他角色的锦囊牌的目标。',
			jiaohui:'教诲',
			jiaohui_info:'结束阶段，若你没有于本回合内造成伤害，你可以令一名角色摸一张牌或回复1点体力。',
			bimeng:'碧梦',
			bimeng_info:'结束阶段，你可以将一张随机梦境牌加入你的手牌。',
			hsmengjing:'梦境',
			hsmengjing_card_config:'梦境',
			hsmengjing_feicuiyoulong:'翡翠幼龙',
			hsmengjing_feicuiyoulong_info:'出牌阶段对任意一名角色使用，对目标造成1点伤害。',
			hsmengjing_huanxiaojiemei:'欢笑姐妹',
			hsmengjing_huanxiaojiemei_info:'出牌阶段对一名已受伤角色使用，令目标恢复1点体力。',
			hsmengjing_suxing:'苏醒',
			hsmengjing_suxing_info:'令所有其他角色失去1点体力并随机弃置两张牌。',
			hsmengjing_mengye:'梦魇',
			hsmengjing_mengye_info:'令一名角色摸一张牌，并在其下一个结束阶段弃置其所有牌。',
			hsmengjing_mengjing:'梦境',
			hsmengjing_mengjing_info:'令一名角色将装备区内的所有牌收入手牌，并将一张乐不思蜀置于其判定区。',
			hszuzhou:'诅咒',
			hszuzhou_nvwudeganguo:'女巫的钳锅',
			hszuzhou_nvwudeganguo_info:'出牌阶段对一名角色使用，目标弃置一张牌，然后随机获得一张炉石衍生牌。',
			hszuzhou_nvwudepingguo:'女巫的苹果',
			hszuzhou_nvwudepingguo_info:'出牌阶段对一名角色使用，目标获得两张杀。',
			hszuzhou_nvwudexuetu:'女巫的学徒',
			hszuzhou_nvwudexuetu_info:'出牌阶段对没有咒降技能的角色使用，令目标非锁定技失效，并获得技能咒降直到下一回合结束。',
			hszuzhou_wushushike:'巫术时刻',
			hszuzhou_wushushike_info:'出牌阶段对所有角色使用，将手牌中的闪替换为杀。',
			hszuzhou_guhuo:'蛊惑',
			hszuzhou_guhuo_info:'出牌阶段对一名其他角色使用，令其交给你一张牌。',
			xjumo:'聚魔',
			xjumo_info:'锁定技，你的手牌上限+3；若你已受伤，改为+5。',
			liehun:'裂魂',
			liehun_info:'锁定技，结束阶段，你获得手牌中所有非基本、非特殊牌的复制。',
			malymowang:'魔网',
			malymowang_info:'锁定技，你的锦囊牌在每回合中造成的首次伤害+1；出牌阶段开始时，你发现一张普通锦囊牌。',
			oldmalymowang:'魔网',
			oldmalymowang_info:'锁定技，你的锦囊牌造成的伤害+1；出牌阶段开始时，你发现一张普通锦囊牌。',
			lingzhou:'灵咒',
			lingzhou_info:'每当你使用一张非转化的锦囊牌，可令一名角色摸一张牌或回复1点体力。',
			mieshi:'灭世',
			mieshi_info:'锁定技，结束阶段，你失去1点体力，并对一名随机的其他角色造成1点火焰伤害。',
			xshixin:'蚀心',
			xshixin_info:'锁定技，每当你对一名其他角色造成一次伤害，受伤害角色与你各失去1点体力。',
			xshixin_info_alter:'锁定技，每当你对一名其他角色造成一次伤害，若受伤害角色体力值不小于你，其与你各失去1点体力。',
			xmojian:'魔箭',
			xmojian_info:'每当你的武将牌翻至正面时，你可以指定一名角色视为对其使用了一张杀。',
			enze:'恩泽',
			enze_info:'出牌阶段限一次，你可以指定一名角色令其手牌数与你相等（最多摸或弃三张牌）。',
			oldenze:'恩泽',
			oldenze_info:'出牌阶段限一次，你可以指定一名角色令其手牌数与你相等。',
			enze_info_alter:'出牌阶段限一次，你可以指定一名角色令其手牌数与你相等（最多摸或弃两张牌）。',
			chongsheng:'重生',
			chongsheng_bg:'生',
			chongsheng_info:'濒死阶段，你可弃置所有牌，将体力回复至2-X，并摸2-X张牌，X为你本局发动此技能的次数。每局最多发动2次。',
			s_tuteng:'神谕',
			s_tuteng_info:'锁定技，准备阶段，你随机获得一个图腾，若你已有至少3个图腾，则改为随机替换一个图腾。',
			guozai:'过载',
			guozai2:'过载',
			guozai2_bg:'载',
			guozai_info:'出牌阶段限一次，你可将手牌补至四张，并于此阶段结束时弃置等量的牌。',
			guozai_info_alter:'出牌阶段限一次，你可将手牌补至三张，并于此阶段结束时弃置等量的牌。',
			guozaix:'过载',
			guozaix2:'过载',
			guozaix2_bg:'载',
			guozaix_info:'出牌阶段限两次，你可将手牌补至四张，并于此阶段结束时弃置等量的牌。',
			oldhanshuang:'寒霜',
			oldhanshuang_info:'锁定技，你使用黑色牌对一名未翻面角色造成伤害后，你令受伤害角色翻面。',
			hanshuang:'寒霜',
			hanshuang_info:'锁定技，你使用黑色牌对一名未翻面角色造成伤害后，你令受伤害角色翻面，然后你失去1点体力。',
			hanshuang_info_alter:'锁定技，你使用黑色牌对一名未翻面角色造成伤害后，你令受伤害角色翻面并摸一张牌，然后你失去1点体力。',
			bingshi:'冰噬',
			bingshi_info:'锁定技，你死亡时，对所有其他角色造成1点伤害。',
			huanwu:'唤雾',
			huanwu_info:'出牌阶段限一次，你可以令一名角色增加1点体力上限，回复1点体力，并摸两张牌（每名角色限发动一次）。',
			fengnu:'风怒',
			fengnu_info:'锁定技，你使用的任何卡牌无数量及距离限制；当你于回合内重复使用同名卡牌时，你摸一张牌（每回合最多以此法摸三张牌）。',
			fengnu_info_alter:'锁定技，你使用的任何卡牌无数量限制；当你于回合内重复使用同名卡牌时，你摸一张牌（每回合最多以此法摸三张牌）。',
			shengdun:'圣盾',
			shengdun2:'圣盾',
			shengdun_info:'锁定技，准备阶段，若你没有护甲，你获得1点护甲。',
			jingmeng:'镜梦',
			jingmeng_info:'每当你于回合内使用第一张牌时，你可以从牌堆中随机获得一张与之类型相同的牌。',
			kuixin:'窥心',
			kuixin_info:'结束阶段，你可以获得一名手牌数不少于你的角色的一张手牌。',
			hswuji:'无羁',
			hswuji_info:'出牌阶段结束时，你可以摸X张牌，X为你本回合使用的卡牌数。',
			yanshu:'炎舞',
			yanshu_info:'每回合限一次，当你弃置非基本牌后，你可以获得一张流星火雨。',
			oldyanshu:'炎舞',
			oldyanshu_info:'当你弃置非基本牌后，你可以获得一张流星火雨。',
			bingshuang:'冰枪',
			bingshuang_info:'你使用锦囊牌造成伤害后，可令目标摸两张牌并翻面。',
			shengyan:'圣言',
			shengyan_info:'任意一名角色回复体力后，你可以令其额外回复1点体力，每回合限发动一次。',
			qingliu:'清流',
			qingliu_info:'锁定技，你防止即将受到的火焰伤害。',
			liechao:'猎潮',
			liechao_info:'出牌阶阶段限一次，若你的武将牌正面朝上且手牌数不大于当前体力值，你可以翻面并摸四张牌，若如此做，你跳过本回合的弃牌阶段。',
			liechao_info_alter:'出牌阶阶段限一次，若你的武将牌正面朝上且手牌数不大于当前体力值，你可以翻面并摸三张牌，若如此做，你跳过本回合的弃牌阶段。',
			aoshu:'奥术',
			aoshu_info:'出牌阶段限一次，你可以将一张黑桃牌当作无中生有使用。',

			qianhou:'千喉',
			qianhou_info:'锁定技，准备阶段，你视为使用一张随机普通锦囊牌（随机指定目标）；若目标只有1人且不是你，你可以弃置一张手牌并获得此锦囊。',
			fengxing:'风行',
			fengxing_info:'每当你于回合外首次失去牌，你可以弃置一张牌并摸两张牌。',
			xinci:'心刺',
			xinci_bg:'暗',
			xinci_info:'出牌阶段限一次，你可以弃置一张黑色牌令一名角色失去1点体力。',
			zhongjia:'战甲',
			zhongjia_info:'锁定技，每当你受到一次伤害，你获得1点护甲；当你的体力值大于1且大于手牌数时，你的护甲不为你抵挡伤害。',
			dunji:'盾击',
			dunji_info:'出牌阶段限一次，你可以对攻击范围内的至多X名其他角色各造成1点伤害，并失去等量的护甲，X为你的护甲数。',
			qiaodong:'巧动',
			qiaodong_info:'你可以将一张装备牌当作闪使用或打出。',
			fengxian:'奉献',
			fengxian_info:'出牌阶段限一次，你可以令场上所有角色各弃置一张手牌。',
			zhanhou:'战吼',
			zhanhou_info:'出牌阶段限一次，你可以弃置一张防具牌并获得1点护甲。',
			oldzhanhou:'战吼',
			oldzhanhou_info:'出牌阶段，你可以弃置一张防具牌并获得1点护甲。',
			anying:'暗影',
			anying_info:'限定技，出牌阶段，你可以弃置一张黑色牌，失去技能圣光，并获得技能心刺。',
			shijie:'视界',
			shijie_info:'结束阶段，你可以获得一名其他角色的一张手牌，然后该角色摸一张牌。',
			shengguang:'圣光',
			shengguang_info:'出牌阶段限一次，你可以弃置一张红色牌令一名角色回复1点体力。',
			bingjia:'冰甲',
			bingjia2:'冰甲',
			bingjia_info:'出牌阶段，若你武将牌上没有牌，你可以将一张手牌背面朝上置于你的武将牌上，当你成为其他角色的与此牌花色相同的牌的目标时，你移去此牌，获得1点护甲，并且本回合内防止一切伤害。',
			bianxing:'变形',
			bianxing_info:'当一其他角色于回合内使用卡牌指定了惟一的其他目标后，你可以用一张合理的基本牌替代此牌，每名角色的回合限一次。',
			xianzhi:'先知',
			xianzhi_info:'任意一名角色进行判定前，你可以观看牌堆顶的两张牌，并可以将其调换顺序。',
			mdzhoufu:'缚魂',
			mdzhoufu2:'缚魂',
			mdzhoufu_info:'出牌阶段，你可以将一张黑色手牌置于一名其他角色的武将牌上，在其判定时以此牌作为判定结果，然后你获得亮出的判定牌。',
			zuzhou:'诅咒',
			zuzhou_info:'锁定技，准备阶段，若场上没有浮雷且你手牌中有黑桃牌，你将牌堆中的一张浮雷置于你的判定区；当一名角色受到浮雷伤害时，你移去此浮雷。',
			zuzhou_old_info:'每当你造成或受到一次伤害，你可以令伤害目标或来源进行一次判定，若结果为黑色，其失去1点体力。',
			jingxiang:'镜像',
			jingxiang_info:'每回合限一次，当你需要打出卡牌时，你可以观看一名角色的手牌并将其视为你的手牌打出。',
			jingxiang_info_alter:'每回合限一次，当你需要打出卡牌时，你可以观看一名手牌数不多于你的角色的手牌并将其视为你的手牌打出。',
			tuteng:'图腾',
			tuteng_info:'出牌阶段，你可以获得一个随机基础图腾；每当你受到一次伤害，你随机失去一个图腾。',
			zuling:'祖灵',
			zuling_info:'觉醒技，准备阶段，若你拥有至少3个图腾，你失去1点体力上限，并将图腾描述中的“获得一个随机基础图腾”改为“获得任意一个图腾（若有4个图腾则改为替换一个图腾）”。',
			tuteng1:'治疗图腾',
			tuteng1_info:'结束阶段，你回复1点体力。',
			tuteng2:'灼热图腾',
			tuteng2_info:'每当你造成一次伤害，你摸一张牌。',
			tuteng3:'石爪图腾',
			tuteng3_info:'你受到下一次伤害时，令伤害-1，然后失去此图腾。',
			tuteng4:'空气图腾',
			tuteng4_info:'在你的回合内，你的锦囊牌造成的首次伤害+1。',
			tuteng5:'法潮图腾',
			tuteng5_info:'结束阶段，你摸一张牌。',
			tuteng6:'火舌图腾',
			tuteng6_info:'在你的回合内，你的杀造成的首次伤害+1。',
			tuteng7:'活力图腾',
			tuteng7_info:'结束阶段，你令一名其他角色回复1点体力。',
			tuteng8:'图腾魔像',
			tuteng8_info:'你的进攻距离+1。',
			tzhenji:'震击',
			tzhenji_info:'每当你因弃置而失去黑色牌，可对一名角色造成1点雷电伤害，并随机弃置其一张牌，每回合限发动一次。',
			fenliu:'分流',
			fenliu_info:'出牌阶段限一次，你可以失去1点体力并获得三张牌。',
			hongxi:'虹吸',
			hongxi_info:'锁定技，每当有一名角色死亡，你将体力回复至体力上限。',
			jihuo:'激活',
			jihuo_info:'在你的回合结束后，你可以弃置一张手牌并进行一个额外的回合。',
			jianren:'刃舞',
			jianren_info:'出牌阶段限一次，你可以弃置装备区内的武器牌，对所有其他角色造成1点伤害。',
			mengun:'闷棍',
			mengun2:'闷棍',
			mengun_info:'每当一名其他角色于回合内使用基本牌，你可以弃置一张与之花色相同的牌令其收回此牌，且在本回合内不能再次使用，每回合限一次。',
			wlianji:'连击',
			wlianji_info:'结束阶段，若你本回合使用的卡牌数大于你当前的体力值，你可以摸两张牌。',
		},
	};
});