'use strict';
game.import('character',function(lib,game,ui,get,ai,_status){
    return {
    	name:'hearth',
    	character:{
    		hs_jaina:['female','wei',3,['huopu','aoshu','bingjia']],
    		hs_lrexxar:['male','shu',4,['yushou']],
    		hs_wuther:['male','qun',4,['fengxian','jieming']],
    		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,['chenshui']],
    		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']],
    		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',3,['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,['mianyi']],
    		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','wei',3,[]],
    		// 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,['guimou','yingxi','longyi']],
    		// hs_xiangyaqishi:['male','wei',3,[]],
    		// hs_fenjie:['male','shu',3,['guimou','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:['fmale','wei',3,['huanjue']],
            hs_shirencao:['male','wu',3,['srjici']],
            hs_kaituozhe:['female','wei',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']],
    	},
    	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:'什么？身为死亡之翼的儿子，拉西奥居然不是龙牌？你似乎知道的太多了…',
    	},
    	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'],
    	},
    	skill:{
            ysjqisha:{
                trigger:{source:'damageEnd',player:'damageEnd'},
                forced:true,
                filter:function(event,player){
                    return (event.source!=player&&event.source.isIn())||(event.player!=player&&event.player.isIn());
                },
                content:function(){
                    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_fake:true,
                },
                subSkill:{
                    ju:{
                        mark:true,
                        intro:{
                            content:'锁定技，每当你使用一张牌，需弃置一张牌'
                        },
                        trigger:{player:'useCard'},
            			forced:true,
            			filter:function(event,player){
            				return player.countCards('he')>0;
            			},
            			content:function(){
            				game.delay(0.5);
            				player.chooseToDiscard(true,'he');
            			}
                    },
                    kuang:{
                        mark:true,
                        intro:{
                            content:'锁定技，每当你使用一张牌指定惟一目标，有50%的机率指定错误的目标'
                        },
                        trigger:{player:'useCard'},
            			forced:true,
            			filter:function(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:function(){
                            '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:function(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.contains(player)) return false;
                            return event.getRand()<0.65;
                        },
                        content:function(){
                            if(trigger.name=='damage'){
                                trigger.num++;
                            }
                            else{
                                trigger.untrigger();
                                trigger.finish();
                            }
                        }
                    },
                    yi:{
                        mark:true,
                        intro:{
                            content:'锁定技，你不能成为非敌方角色的卡牌目标'
                        },
                        mod:{
            				targetEnabled:function(card,player,target){
            					if(!player.getEnemies().contains(target)) return false;
            				}
            			}
                    },
                    wang:{
                        mark:true,
                        intro:{
                            content:'锁定技，你的摸牌数始终-1'
                        },
                        trigger:{player:'drawBegin'},
                        forced:true,
                        content:function(){
                            trigger.num--;
                        }
                    },
                    hen:{
                        mark:true,
                        intro:{
                            content:'锁定技，每当一名敌方角色回复一点体力，你失去一点体力'
                        },
                        trigger:{global:'recoverAfter'},
                        forced:true,
                        filter:function(event,player){
                            return player.getEnemies().contains(event.player);
                        },
                        content:function(){
                            player.loseHp();
                        }
                    },
                    ao:{
                        mark:true,
                        intro:{
                            content:'锁定技，你的手牌上限-2'
                        },
                        mod:{
                            maxHandcard:function(player,num){
                                return num-2;
                            }
                        }
                    },
                }
            },
            yindan:{
                enable:'phaseUse',
                filterCard:{suit:'spade'},
                check:function(card){
                    return 8-get.value(card);
                },
                usable:1,
                filter:function(event,player){
                    return player.countCards('he',{suit:'spade'});
                },
                position:'he',
                content:function(){
                    '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:function(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:function(event,player){
                    return game.hasPlayer(function(target){
                        return lib.skill.hllingxi.filterTarget(null,player,target);
                    });
                },
                filterTarget:function(card,player,target){
                    return target!=player&&target.isDamaged()&&target.countCards('he')>=2;
                },
                content:function(){
                    'step 0'
                    target.chooseToDiscard('he',2,true);
                    'step 1'
                    target.recover();
                },
                group:'hllingxi_end',
                subSkill:{
                    end:{
                        trigger:{player:'phaseEnd'},
                        frequent:true,
                        filter:function(event,player){
                            return player.isDamaged();
                        },
                        content:function(){
                            player.recover();
                        }
                    }
                },
                ai:{
                    order:6,
                    result:{
                        target:function(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:function(event,player){
                    return player.getEnemies().length>0;
                },
                content:function(){
                    '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'},
                forced:true,
                popup:false,
                silent:true,
                filter:function(event){
                    return event.getParent(2).name=='zhaochao';
                },
                content:function(){
                    player.storage.zhaochao2=true;
                }
            },
            xiyong:{
                trigger:{player:'phaseEnd'},
                frequent:true,
                content:function(){
                    '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:function(){
                    player.draw();
                    if(trigger.player&&trigger.player.isIn()){
                        trigger.player.randomDiscard();
                    }
                },
                ai:{
                    threaten:1.4
                }
            },
            yinzong:{
    			trigger:{player:'loseEnd'},
    			forced:true,
    			filter:function(event,player){
					for(var i=0;i<event.cards.length;i++){
						if(event.cards[i].original=='e') return true;
					}
    				return false;
    			},
    			content:function(){
    				player.addTempSkill('qianxing',{player:'phaseBegin'});
    			}
    		},
            tansuo:{
                enable:'phaseUse',
    			usable:1,
    			filterCard:true,
    			position:'he',
    			check:function(card){
    				return 8-get.value(card)
    			},
    			content:function(){
                    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.gainnable==false) continue;
                        if(lib.characterPack.hearth[info.derivation]){
                            list.push(name);
                        }
                    }
                    if(!list.length){
                        player.draw();
                    }
                    else{
                        player.gain(game.createCard(list.randomGet()),'draw');
                    }
    			},
    			ai:{
                    threaten:1.6,
    				order:8,
    				result:{
    					player:1
    				},
    			}
            },
            lieqi:{
                trigger:{player:['phaseBegin','phaseEnd']},
                filter:function(event,player){
                    return game.hasPlayer(function(current){
                        return !current.isUnderControl(true,player)&&current!=player.storage.lieqi&&current.countCards('h');
                    });
                },
                direct:true,
                content:function(){
                    '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.get('h').randomSort();
                        if(hs.length){
                            var list2=[];
                            for(var i=0;i<hs.length;i++){
                                if(list2.contains(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.contains(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.rand) _status.event.rand=Math.random();
                                if(_status.event.rand<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:function(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:function(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:function(button){
    					var player=_status.event.player;
    					var card={name:button.link[2],nature:button.link[3]};
                        if(!_status.event.rand) _status.event.rand=Math.random();
    					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]=='fire') return 2.92;
    								else return 2.9;
                                    break;
                                default:return 2+_status.event.rand*2;
    						}
    					}
    					return 0;
    				},
    				backup:function(links,player){
    					return {
    						filterCard:function(card){
    							return get.type(card)=='basic';
    						},
    						viewAs:{name:links[0][2],nature:links[0][3]},
    						popname:true,
                            ai1:function(card){
                                return 6-get.value(card);
                            }
    					}
    				},
    				prompt:function(links,player){
    					return '将一张基本牌当作'+get.translation(links[0][3]||'')+get.translation(links[0][2])+'使用';
    				}
    			},
    			ai:{
    				order:function(){
    					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:function(event,player){
    				return event.type=='dying'&&event.dying&&!event.dying.hasSkill('shouwang2');
    			},
    			filterTarget:function(card,player,target){
    				return target==_status.event.dying;
    			},
    			selectTarget:-1,
    			content:function(){
    				target.recover();
    				target.changeHujia();
                    target.addSkill('shouwang2')
    			},
    			ai:{
    				order:6,
    				skillTagFilter:function(player){
    					if(!_status.event.dying||_status.event.dying.hasSkill('shouwang2')) return false;
    				},
    				save:true,
    				result:{
    					target:3
    				},
    				threaten:1.6
    			},
            },
            shouwang2:{
                mark:true,
                intro:{
                    content:'已发动'
                }
            },
            qingtian:{
                trigger:{player:'recoverBefore'},
                forced:true,
                filter:function(event,player){
                    return player.hp>0&&event.num>0;
                },
                content:function(){
                    trigger.untrigger();
                    trigger.finish();
                    player.changeHujia(trigger.num);
                }
            },
            qianfu:{
                trigger:{player:'dieBefore'},
                forced:true,
                filter:function(event,player){
                    return !player.hasSkill('qianfu2')&&player.maxHp>0;
                },
                unique:true,
                content:function(){
                    trigger.untrigger();
                    trigger.finish();
                    player.addSkill('qianfu2');
                    player.hp=1;
                    player.update();
                    player.discard(player.get('he'));
                    player.setAvatar('hs_selajin','hs_selajin2');
                },
                ai:{
                    threaten:0.8
                }
            },
            qianfu2:{
                mark:true,
                intro:{
                    content:'你防止非火焰伤害，不能使用或打出卡牌，并始终跳过你的回合'
                },
                mod:{
					cardEnabled:function(card,player){
						return false;
					},
					cardUsable:function(card,player){
						return false;
					},
					cardRespondable:function(card,player){
						return false;
					},
					cardSavable:function(card,player){
						return false;
					},
				},
                group:['qianfu2_damage','qianfu2_phase','qianfu2_revive'],
                subSkill:{
                    damage:{
                        trigger:{player:'damageBefore'},
        				filter:function(event){
        					if(event.nature!='fire') return true;
        					return false;
        				},
        				mark:true,
        				forced:true,
        				content:function(){
        					trigger.untrigger();
        					trigger.finish();
        				},
        				ai:{
        					nothunder:true,
        					nodamage:true,
        					effect:{
        						target:function(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:function(){
                            trigger.untrigger();
                            trigger.finish();
                        }
                    },
                    revive:{
                        trigger:{player:'recoverAfter'},
                        forced:true,
                        filter:function(event,player){
                            return player.hp>=3||player.isHealthy();
                        },
                        content:function(){
                            player.removeSkill('qianfu2');
                            player.draw(3);
                            player.setAvatar('hs_selajin2','hs_selajin');
                        }
                    }
                }
            },
            shimo:{
                trigger:{global:'damageAfter'},
                forced:true,
                filter:function(event,player){
                    return event.player!=player&&get.distance(player,event.player)<=1;
                },
                content:function(){
                    if(player.isDamaged()){
                        player.recover();
                    }
                    else{
                        player.draw();
                    }
                }
            },
            lieyang:{
                trigger:{player:'useCard'},
                forced:true,
                usable:3,
                filter:function(event,player){
                    return _status.currentPhase==player&&get.type(event.card,'trick')=='trick';
                },
                content:function(){
                    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','phaseAfter');
                    }
                },
                ai:{
                    threaten:1.8
                }
            },
            lieyang2:{
                mod:{
                    cardEnabled:function(card){if(get.type(card,'trick')=='trick') return false}
                }
            },
            zhuilie:{
                trigger:{player:'phaseBegin'},
                direct:true,
                filter:function(event,player){
                    return player.countCards('he');
                },
                content:function(){
                    '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'){
                                ui.discardPile.appendChild(list[i]);
                                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:function(){
                    return game.roundNumber>=3;
                },
    			check:function(event,player){
                    return player.hp<=2;
    			},
    			content:function(){
    				'step 0'
                    var list=[];
					for(var i in lib.character){
						if(!lib.filter.characterDisabled(i)&&lib.character[i][2]>=5){
							list.push(i);
						}
					}
    				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)-lib.character[button.link][2];
    				};
    				player.awakenSkill('fuhan');
    				'step 1'
    				player.reinit('hs_shizugui',result.links[0]);
                    player.hp=player.maxHp;
                    player.update();
    			}
    		},
            kekao:{
                trigger:{player:'phaseEnd'},
    			direct:true,
    			content:function(){
    				'step 0'
    				var list=[];
                    for(var i in lib.card){
                        if(game.bannedcards&&game.bannedcards.contains(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:function(event,player){
                    return get.type(event.card,'trick')=='trick'&&event.player==player&&event.cards[0]&&event.cards[0]==event.card;
                },
    			content:function(){
    				'step 0'
    				var list=get.gainableSkills();
    				list.remove(player.getSkills());
    				list=list.randomGets(3);
    				event.skillai=function(){
    					return list.randomGet();
    				};
    				if(event.isMine()){
    					var dialog=ui.create.dialog();
    					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:50%;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:function(card,player,target){
                            if(get.type(card,'trick')=='trick'&&player==target) return [1,1];
                        }
    				}
    			}
    		},
            kqizhou:{
                trigger:{player:'phaseBegin'},
                direct:true,
                filter:function(event,player){
                    return player.storage.kqizhou;
                },
                content:function(){
                    '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'},
                        forced:true,
                        popup:false,
                        silent:true,
                        filter:function(event,player){
                            return _status.currentPhase==player&&get.type(event.card,'trick')=='trick';
                        },
                        content:function(){
                            player.storage.kqizhou=true;
                        }
                    }
                }
            },
            jingcu:{
                enable:'phaseUse',
                filter:function(event,player){
                    return player.maxHp>1;
                },
                content:function(){
                    'step 0'
                    player.loseMaxHp(true);
                    'step 1'
                    player.draw(2);
                },
                ai:{
                    order:1.5,
                    threaten:1.4,
                    result:{
                        player:function(player){
                            if(player.isDamaged()) return 1;
                            if(player.hp>=3&&!player.needsToDiscard(2)) return 1;
                            return 0;
                        }
                    }
                },
            },
            shengzhang:{
                trigger:{player:'phaseDiscardEnd'},
                forced:true,
                filter:function(event,player){
                    return event.cards&&event.cards.length>0;
                },
                content:function(){
                    player.gainMaxHp(true);
                }
            },
            pyuhuo:{
                unique:true,
                skillAnimation:true,
                animationColor:'fire',
                trigger:{player:'dying'},
                priority:10,
                filter:function(event,player){
                    return player.storage.pyuhuo!='over';
                },
                forced:true,
                content:function(){
                    'step 0'
                    player.discard(player.get('hej'));
                    'step 1'
                    player.link(false);
                    'step 2'
                    player.turnOver(false);
                    'step 3'
                    if(player.storage.pyuhuo){
                        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=true;
                        player.hp=4;
                        player.maxHp=4;
                        player.draw(4);
                        player.setAvatar('hs_pyros','hs_pyros1');
                    }
                },
                ai:{
                    threaten:function(player,target){
                        if(target.storage.pyuhuo!='over') return 0.6;
                        return 1;
                    }
                }
            },
            mengye:{
                trigger:{player:'phaseEnd'},
                direct:true,
                filter:function(event,player){
                    return game.hasPlayer(function(current){
                        return current!=player&&current.countCards('h');
                    });
                },
                content:function(){
                    '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:function(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:function(){
    				'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',
    			intro:{
    				content:'由$控制本回合行动'
    			},
    			init:function(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:function(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:function(){
    				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:function(){
    				if(player.getStat().damage>trigger.num){
    					player.gainMaxHp();
    					player.recover();
    				}
    				else{
    					player.draw(2);
    				}
    			}
    		},
    		lianzhan2:{},
    		kuixin:{
    			trigger:{player:'phaseEnd'},
    			direct:true,
    			filter:function(event,player){
    				return game.hasPlayer(function(current){
    					if(current==player) return false;
    					var nh=current.countCards('h');
    					return nh&&nh>=player.countCards('h');
    				});
    			},
    			content:function(){
    				'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:function(){return 1},
    			filterTarget:function(card,player,target){
    				return !target.hasSkill('moxie')&&!target.storage.fuhua_failed;
    			},
    			filter:function(event,player){
    				return player.countCards('h','du');
    			},
    			discard:false,
    			prepare:'give',
    			content:function(){
    				'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:2,
    				order:8,
    				expos:0.2,
    				result:{
    					player:function(player,target){
    						if(get.attitude(target,player)>0) return 1;
    						if(get.effect(target,{name:'juedou'},player,player)>0) return 1.5;
    						return 0;
    					}
    				}
    			},
    			group:'fuhua3'
    		},
    		fuhua2:{
    			trigger:{player:'phaseUseBegin'},
    			forced:true,
    			filter:function(event,player){
    				return player.storage.fuhua2.isIn()&&player.countCards('he')>0;
    			},
    			mark:'character',
    			intro:{
    				content:function(storage){
    					return '每个出牌阶段开始时需交给'+get.translation(storage)+'一张牌';
    				}
    			},
    			content:function(){
    				'step 0'
    				player.chooseCard('he',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:function(event,player){
    						return event.player==player.storage.fuhua2;
    					},
    					content:function(){
    						player.removeSkill('fuhua2');
    					}
    				}
    			}
    		},
    		fuhua3:{
    			trigger:{player:'damageBefore'},
    			forced:true,
    			popup:false,
    			filter:function(event,player){
    				var evt=event.getParent(3);
    				return evt.name=='fuhua'&&evt.target==event.source;
    			},
    			content:function(){
    				trigger.getParent(3).target.storage.fuhua_failed=true;
    			}
    		},
    		moxie:{
    			trigger:{player:'duBegin'},
    			forced:true,
    			content:function(){
    				player.draw(2);
    			},
    			ai:{
    				threaten:1.2,
    				nodu:true,
    				usedu:true,
    			},
    			group:'moxie2'
    		},
    		moxie2:{
    			trigger:{player:'phaseEnd'},
    			forced:true,
    			filter:function(event,player){
    				return player.countCards('h')>0;
    			},
    			content:function(){
    				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:function(event,player){
    				return game.hasPlayer(function(current){
    					return current.hp>player.hp;
    				});
    			},
    			logTarget:function(event,player){
    				return game.filterPlayer(function(current){
    					return current.hp>player.hp;
    				});
    			},
    			content:function(){
    				'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)+'一张黑色牌，或失去一点体力',{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:function(event,player){
    				return player.countCards('h')>0&&!player.isTurnedOver();
    			},
    			content:function(){
    				'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:function(){
                    '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.chooseCard('是否将一张手牌转化为'+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];
                        card.init([card.suit,card.number,event.cardname]);
                        player.$draw(game.createCard({name:event.cardname,suit:' ',number:' '}));
                        game.log(player,'将一张手牌转化为',{name:event.cardname});
                    }
    			}
    		},
    		longyi:{
    			mod:{
    				maxHandcard:function(player,num){
    					var hs=player.getCards('h');
    					for(var i=0;i<hs.length;i++){
    						if(get.color(hs[i])=='black'){
    							num++;
    						}
    					}
    					return num;
    				},
    			},
    		},
    		zhongji:{
    			trigger:{source:'damageBegin'},
    			direct:true,
    			filter:function(event,player){
    				return player.countCards('h',{color:'black'})>0;
    			},
    			content:function(){
    				"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:function(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:function(){
    				player.changeHujia();
    			},
    		},
    		jinzhou:{
    			trigger:{player:'phaseEnd'},
    			direct:true,
    			filter:function(event,player){
    				return player.countCards('h',{suit:'spade'})>0;
    			},
    			content:function(){
    				'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:function(event,player){
    				return player.countCards('h',{type:['trick','delay']})>0;
    			},
    			filterCard:{type:['trick','delay']},
    			check:function(card){
    				return 10-get.value(card);
    			},
    			content:function(){
    				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:function(event,player){
    				return !player.isMostHandcard();
    			},
    			content:function(){
    				'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:function(event,player){
    				return event.type=='dying'&&player.countCards('he',{color:'black'});
    			},
    			alter:true,
    			filterCard:{color:'black'},
    			position:'he',
    			check:function(card){
    				return 11-get.value(card);
    			},
    			filterTarget:function(card,player,target){
    				return target==_status.event.dying;
    			},
    			selectTarget:-1,
    			content:function(){
    				target.recover();
    				if(!get.is.altered('yuelu')) target.changeHujia();
    			},
    			ai:{
    				order:10,
    				skillTagFilter:function(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:function(card){
    				return 5-get.value(card);
    			},
    			filter:function(event,player){
    				if(player.hasSkill('yushou_misha')&&player.hasSkill('yushou_huofu')&&player.hasSkill('yushou_leiouke')) return false;
    				return true;
    			},
    			content:function(){
    				if(!lib.character.stone_misha){
    					lib.character.stone_misha=['male','shu',3,['chaofeng'],['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'},
    			forced:true,
    			popup:false,
    			silent:true,
    			content:function(){
    				var list=['yushou_misha','yushou_huofu','yushou_leiouke'];
    				var skills=player.getSkills();
    				for(var i=0;i<list.length;i++){
    					if(!skills.contains(list[i])) list.splice(i--,1);
    				}
    				if(list.length){
    					player.removeSkill(list.randomGet());
    				}
    			}
    		},
    		yushou_misha:{
    			trigger:{player:'damageBegin'},
    			forced:true,
    			filter:function(event,player){
    				return event.num>=1;
    			},
    			usable:1,
    			content:function(){
    				if(trigger.num>=1){
    					trigger.num--;
    					// player.removeSkill('yushou_misha');
    					// player.draw();
    				}
    			},
    			ai:{
    				effect:{
    					target:function(card,player,target){
    						if(get.tag(card,'damage')){
    							if(player.hasSkillTag('jueqing')) return;
    							return 0.5;
    						}
    					}
    				}
    			},
    		},
    		yushou_huofu:{
    			enable:'phaseUse',
    			viewAs:{name:'juedou'},
    			filterCard:{color:'black'},
    			position:'he',
    			viewAsFilter:function(player){
    				if(!player.countCards('he',{color:'black'})) return false;
    			},
    			check:function(card){
    				return 6-get.value(card);
    			},
    			ai:{
    				basic:{
    					order:10
    				}
    			}
    		},
    		yushou_leiouke:{
    			trigger:{source:'damageBegin'},
    			forced:true,
    			usable:1,
    			content:function(){
    				trigger.num++;
    			}
    		},
    		qingzun:{
    			alter:true,
    			subSkill:{
    				count:{
    					trigger:{player:'useCard'},
    					forced:true,
    					popup:false,
    					silent:true,
    					filter:function(event,player){
    						return event.card.name.indexOf('hsqingyu_')==0;
    					},
    					content:function(){
    						player.storage.qingzun++;
    						player.updateMarks();
    					}
    				},
    				draw1:{
    					trigger:{player:'phaseBegin'},
    					filter:function(event,player){
    						if(get.is.altered('qingzun')) return player.storage.qingzun>=3;
    						return player.storage.qingzun>=2;
    					},
    					frequent:true,
    					content:function(){
    						player.draw();
    					}
    				},
    				draw2:{
    					trigger:{player:'phaseEnd'},
    					filter:function(event,player){
    						if(get.is.altered('qingzun')) return player.storage.qingzun>=9;
    						return player.storage.qingzun>=6;
    					},
    					frequent:true,
    					content:function(){
    						player.draw();
    					}
    				},
    			},
    			mod:{
    				maxHandcard:function(player,num){
    					return num+player.storage.qingzun;
    				}
    			},
    			init:function(player){
    				player.storage.qingzun=0;
    			},
    			mark:true,
    			marktext:'玉',
    			intro:{
    				content:function(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:function(){
    				var list=['feibiao','hufu','zhao','zhanfang','shandian'];
    				player.gain(game.createCard('hsqingyu_'+list.randomGet()),'draw');
    			},
    			ai:{
    				maixie:true,
    				maixie_hp:true,
    				effect:{
    					target:function(card,player,target){
    						if(get.tag(card,'damage')){
    							if(player.hasSkillTag('jueqing')) 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:function(card){
    				return get.suit(card)=='spade';
    			},
    			viewAs:{name:'wuzhong'},
    			viewAsFilter:function(player){
    				if(!player.countCards('he',{suit:'spade'})) return false;
    			},
    			prompt:'将一张黑桃手牌当作无中生有使用',
    			check:function(card){return 7-get.value(card)},
    			ai:{
    				threaten:1.4,
    				order:9,
    			}
    		},
    		bzhuiji:{
    			trigger:{global:'dieAfter'},
    			check:function(event,player){
    				return get.attitude(player,event.source)<=0;
    			},
    			filter:function(event,player){
    				return event.source&&event.source.isAlive()&&event.source!=player;
    			},
    			content:function(){
    				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:function(card){
    				return 7-get.value(card);
    			},
    			content:function(){
    				'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:2,
    			filterCard:function(card){
    				return get.type(card)!='hsyaoshui';
    			},
    			check:function(card){
    				return 8-get.value(card)
    			},
    			discard:false,
    			lose:false,
    			delay:false,
    			content:function(){
    				'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]);
    				}
    				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);
    				'step 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);
    				'step 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:function(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:function(){
    					'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:function(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.contains('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
    			},
    		},
    		shouji:{
    			group:['shouji_begin','shouji_miss'],
    			subSkill:{
    				begin:{
    					trigger:{player:'shaBegin'},
    					frequent:true,
    					usable:1,
    					filter:function(event){
    						return event.target.countCards('h')>0;
    					},
    					content:function(){
    						player.gain(game.createCard(trigger.target.getCards('h').randomGet()),'draw');
    					}
    				},
    				miss:{
    					trigger:{player:'shaMiss'},
    					frequent:true,
    					usable:1,
    					filter:function(event){
    						return event.target.hasCard(function(card){
    							return !get.info(card).unique;
    						},'e');
    					},
    					content:function(){
    						player.gain(game.createCard(trigger.target.getCards('e',function(card){
    							return !get.info(card).unique;
    						}).randomGet()),'draw');
    					}
    				}
    			}
    		},
    		yingxi:{
    			trigger:{player:'phaseEnd'},
    			direct:true,
    			filter:function(event,player){
    				return !player.getStat('damage')&&player.countCards('he',{color:'black'})>0;
    			},
    			content:function(){
    				'step 0'
    				player.chooseCardTarget({
    					prompt:get.prompt('yingxi'),
    					filterCard:{color:'black'},
    					filterTarget:function(card,player,target){
    						return lib.filter.targetEnabled({name:'sha'},player,target);
    					},
    					position:'he',
    					ai1:function(card){
    						return 8-get.value(card);
    					},
    					ai2:function(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:function(event,player){
    				return event.skill=='yingxi'&&event.target.isHealthy();
    			},
    			content:function(){
    				trigger.directHit=true;
    			}
    		},
    		guimou:{
    			trigger:{player:'damageEnd'},
    			check:function(event,player){
    				return get.attitude(player,event.source)<=0;
    			},
    			filter:function(event,player){
    				return event.source&&event.source.isAlive()&&event.source!=player&&event.source.countCards('h')>0;
    			},
    			content:function(){
    				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,
    				effect:{
    					target:function(card,player,target){
    						if(player.hasSkillTag('jueqing')) 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:function(){
    				'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'},
    			forced:true,
    			popup:false,
    			silent:true,
    			content:function(){
    				player.removeAdditionalSkill('peiyu');
    			}
    		},
    		peiyu_old:{
    			enable:'phaseUse',
    			filterCard:true,
    			position:'he',
    			filterTarget:true,
    			check:function(card){
    				return 6-get.value(card);
    			},
    			content:function(){
    				'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.contains(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.contains(current)){
    									return rand2.contains(button.name);
    								}
    								else{
    									return rand.contains(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.contains('tuteng1')){
    								gain='tuteng1';
    							}
    							else if(rand.contains('tuteng3')){
    								gain='tuteng3';
    							}
    							else{
    								gain=rand.randomGet();
    							}
    							target.removeSkill(rand2.randomGet())
    						}
    						else{
    							if(rand2.contains('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:function(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:function(){
    				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:function(event,player){
    				return player.countCards('h')+2<=player.hp;
    			},
    			content:function(){
    				'step 0'
    				event.cards=get.cards(3);
    				trigger.untrigger();
    				trigger.finish();
    				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:function(event){
    				return event.card&&get.type(event.card)=='trick';
    			},
    			content:function(){
    				player.gainMaxHp(true);
    				player.recover();
    			},
    		},
    		yuansu:{
    			enable:'phaseUse',
    			usable:1,
    			filter:function(event,player){
    				return player.maxHp-player.hp>=3;
    			},
    			filterTarget:function(card,player,target){
    				return player.canUse('yuansuhuimie',target);
    			},
    			selectTarget:-1,
    			multitarget:true,
    			multiline:true,
    			line:'thunder',
    			content:function(){
    				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:function(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:function(){
    				player.loseMaxHp();
    				player.changeHujia(2);
    				player.removeSkill('nuyan');
    				player.addSkill('nuyan2');
    				player.awakenSkill('chouhuo');
    			}
    		},
    		nuyan2:{
    			enable:'phaseUse',
    			usable:3,
    			chooseButton:{
    				dialog:function(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:function(button,player){
    					return lib.filter.filterCard({name:button.link[2]},player,_status.event.getParent());
    				},
    				check:function(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:function(links,player){
    					return {
    						filterCard:function(){return false},
    						selectCard:-1,
    						popname:true,
    						viewAs:{name:links[0][2]},
    						onuse:function(result,player){
    							player.loseHp();
    						}
    					}
    				},
    				prompt:function(links,player){
    					return '失去一点体力，视为使用一张'+get.translation(links[0][2]);
    				}
    			},
    			ai:{
    				order:6,
    				result:{
    					player:function(player){
    						if(player.hp>1) return 1;
    						return 0;
    					}
    				},
    			}
    		},
    		nuyan:{
    			enable:'phaseUse',
    			usable:1,
    			filter:function(event,player){
    				return player.countCards('he',{color:'red'})>0
    			},
    			init:function(player){
    				player.storage.nuyan=[];
    			},
    			chooseButton:{
    				dialog:function(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:function(button,player){
    					if(player.storage.nuyan.contains(button.link[2])) return false;
    					return lib.filter.filterCard({name:button.link[2]},player,_status.event.getParent());
    				},
    				check:function(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:function(links,player){
    					return {
    						filterCard:{color:'red'},
    						selectCard:1,
    						position:'he',
    						popname:true,
    						viewAs:{name:links[0][2]},
    						ai1:function(card){
    							return 6-get.value(card);
    						},
    						onuse:function(result,player){
    							player.storage.nuyan.add(result.card.name);
    						}
    					}
    				},
    				prompt:function(links,player){
    					return '将一张红色牌当作'+get.translation(links[0][2])+'使用';
    				}
    			},
    			ai:{
    				order:6,
    				result:{
    					player:1
    				},
    			}
    		},
    		duxin:{
    			trigger:{player:['phaseBegin','phaseEnd']},
    			frequent:true,
    			filter:function(event,player){
    				return !player.countCards('h',{type:'hsdusu'});
    			},
    			content:function(){
    				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:function(){
    				trigger.num++;
    				player.removeSkill('hsdusu_shinancao');
    			}
    		},
    		kuangluan_old:{
    			group:['kuangluan_count1','kuangluan_count2','kuangluan_use'],
    			subSkill:{
    				count1:{
    					trigger:{player:'useCard'},
    					forced:true,
    					popup:false,
    					silent:true,
    					filter:function(event,player){
    						return _status.currentPhase==player&&get.type(event.card)=='trick';
    					},
    					content:function(){
    						player.storage.kuangluan++;
    					}
    				},
    				count2:{
    					trigger:{player:'phaseBegin'},
    					forced:true,
    					popup:false,
    					silent:true,
    					content:function(){
    						player.storage.kuangluan=0;
    					}
    				},
    				use:{
    					trigger:{player:'phaseUseEnd'},
    					forced:true,
    					filter:function(event,player){
    						return player.storage.kuangluan>0;
    					},
    					content:function(){
    						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:function(event,player){
    				return event.source&&event.source.isIn()&&event.source!=player;
    			},
    			intro:{
    				content:'players'
    			},
    			content:function(){
    				trigger.source.goMad('phaseAfter');
    				// if(!player.storage.kuangluan){
    				// 	player.storage.kuangluan=[];
    				// }
    				// player.storage.kuangluan.add(trigger.source);
    				// player.markSkill('kuangluan');
    			},
    			ai:{
    				threaten:0.3
    			},
    			// group:['kuangluan2','kuangluan3']
    		},
    		kuangluan2:{
    			trigger:{player:'phaseBegin'},
    			priority:10,
    			forced:true,
    			filter:function(event,player){
    				return player.storage.kuangluan&&player.storage.kuangluan.length>=2;
    			},
    			content:function(){
    				player.recover(player.maxHp);
    				player.goMad('phaseAfter');
    			}
    		},
    		kuangluan3:{
    			trigger:{player:'phaseBegin'},
    			forced:true,
    			popup:false,
    			silent:true,
    			content:function(){
    				player.storage.kuangluan=[];
    				player.unmarkSkill('kuangluan');
    			}
    		},
    		xiubu:{
    			trigger:{player:'equipEnd'},
    			frequent:true,
    			filter:function(event){
    				return lib.inpile.contains(event.card.name)&&get.subtype(event.card)=='equip1'&&typeof lib.cardType.hslingjian=='number';
    			},
    			content:function(){
    				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');
    				var cards=[];
    				while(num--){
    					cards.push(game.createCard(list.randomGet()));
    				}
    				player.gain(cards,'gain2');
    			},
    			threaten:1.3
    		},
    		zengli:{
    			enable:'phaseUse',
    			usable:1,
    			filterTarget:function(card,player,target){
    				return target!=player&&!target.isMin();
    			},
    			delay:false,
    			content:function(){
    				'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:function(player,target){
    						if(target.getEquip(1)) return 0;
    						return 1;
    					}
    				}
    			}
    		},
    		mobao:{
    			enable:'phaseUse',
    			usable:1,
    			filter:function(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:function(card,player,target){
    				return player.storage.mobao.contains(target);
    			},
    			position:'he',
    			selectTarget:-1,
    			selectCard:[1,3],
    			check:function(card){
    				return 8-get.value(card);
    			},
    			filterCard:{color:'black'},
    			line:'thunder',
    			content:function(){
    				target.damage('thunder',cards.length);
    			},
    			ai:{
    				order:9,
    				threaten:0.7,
    				result:{
    					target:function(player,target){
    						return get.damageEffect(target,player,target,'thunder');
    					}
    				}
    			},
    			group:['mobao2','mobao3']
    		},
    		mobao2:{
    			trigger:{player:'damageEnd'},
    			forced:true,
    			silent:true,
    			popup:false,
    			filter:function(event,player){
    				return event.source&&event.source!=player;
    			},
    			content:function(){
    				if(!player.storage.mobao){
    					player.storage.mobao=[];
    				}
    				player.storage.mobao.add(trigger.source);
    			}
    		},
    		mobao3:{
    			trigger:{player:'phaseEnd'},
    			forced:true,
    			silent:true,
    			popup:false,
    			content:function(){
    				delete player.storage.mobao;
    			}
    		},
    		xianji:{
    			unique:true,
    			forceunique:true,
    			global:'xianji2'
    		},
    		xianji2:{
    			trigger:{player:'phaseEnd'},
    			direct:true,
    			filter:function(event,player){
    				if(player.hasSkill('xianji')) return false;
    				if(player.hasSkill('xianji3')) return true;
    				return game.hasPlayer(function(current){
    					return current.hasSkill('xianji');
    				});
    			},
    			content:function(){
    				'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:function(event,player){
    				return event.player==player.storage.xianji3;
    			},
    			forced:true,
    			content:function(){
    				player.draw();
    			},
    		},
    		tanmi:{
    			trigger:{global:'phaseEnd'},
    			filter:function(event,player){
    				return player.countCards('h')==0&&event.player!=player;
    			},
    			frequent:true,
    			content:function(){
    				'step 0'
    				player.draw(2);
    				'step 1'
    				player.chooseToUse();
    				'step 2'
    				if(result.bool){
    					player.chooseToUse();
    				}
    			},
    			ai:{
    				noh:true,
    				skillTagFilter:function(player,tag){
    					if(tag=='noh'){
    						if(player.countCards('h')!=1) return false;
    					}
    				}
    			}
    		},
    		xueren:{
    			trigger:{source:'damageEnd'},
    			filter:function(event){
    				return event.card&&event.card.name=='sha'&&event.player.isAlive();
    			},
    			check:function(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:function(){
    				'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:function(){
    				'step 0'
    				var list=get.gainableSkills();
    				list.remove('maoxian');
    				list=list.randomGets(3);
    				event.skillai=function(){
    					return list.randomGet();
    				};
    				if(event.isMine()){
    					var dialog=ui.create.dialog();
    					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:50%;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:function(storage,player){
    					return '当前技能：'+get.translation(player.additionalSkills.maoxian);
    				}
    			},
    			ai:{
    				order:11,
    				result:{
    					player:function(player){
    						if(player.getStat().skill.maoxian) return 0;
    						return 1;
    					}
    				}
    			}
    		},
    		maoxian_old:{
    			enable:'phaseUse',
    			usable:2,
    			direct:true,
    			delay:false,
    			unique:true,
    			getSkills:function(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:function(player){
    				player.removeAdditionalSkill('maoxian');
    			},
    			content:function(){
    				'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:function(player){
    						if(player.getStat().skill.maoxian) return 0;
    						return 1;
    					}
    				}
    			}
    		},
    		yiwen:{
    			trigger:{target:'useCardToBegin'},
    			filter:function(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:function(){
    				player.gain(game.createCard(trigger.card),'gain2');
    				trigger.player.addTempSkill('yiwen2','phaseAfter');
    			},
    			ai:{
    				threaten:0.7
    			}
    		},
    		yiwen2:{},
    		tanbao_old:{
    			enable:'phaseUse',
    			usable:1,
    			filter:function(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.contains(type)){
    						return false;
    					}
    					else{
    						types.push(type);
    					}
    				}
    				return true;
    			},
    			content:function(){
    				'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:function(card){
    				if(_status.event.player.hp==1){
    					return 7-get.value(card);
    				}
    				return 6-get.value(card);
    			},
    			selectCard:3,
    			filter:function(event,player){
    				return player.countCards('he')>=3;
    			},
    			content:function(){
    				'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:function(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:function(card){
    				return 8-get.value(card);
    			},
    			selectCard:[1,Infinity],
    			content:function(){
    				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:function(card){
    				if(ui.selected.cards.length) return 0;
    				return 6-get.value(card)
    			},
    			content:function(){
    				'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++){
    					ui.discardPile.appendChild(event.cards[i]);
    				}
    			},
    			ai:{
    				order:8,
    				result:{
    					player:1
    				},
    			}
    		},
    		xunbao:{
    			trigger:{player:'phaseBegin'},
    			frequent:true,
    			filter:function(event,player){
    				return !player.hasSkill('xunbao2');
    			},
    			priority:1,
    			// filterCard:true,
    			// check:function(card){
    			// 	return 6-get.value(card);
    			// },
    			// position:'he',
    			content:function(){
    				'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).animate('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:function(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:function(){
    				'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:function(){
    				player.gain(game.createCard('hsbaowu_huangjinyuanhou'),'gain2');
    				player.removeSkill('hsbaowu_cangbaotu');
    			}
    		},
    		hsbaowu_huangjinyuanhou:{
    			mark:'card',
    			nopup:true,
    			intro:{
    				content:'锁定技，你不能成为其他角色的卡牌的目标'
    			},
    			mod:{
    				targetEnabled:function(card,player,target){
    					if(player!=target) return false;
    				}
    			},
    			group:'hsbaowu_huangjinyuanhou2'
    		},
    		hsbaowu_huangjinyuanhou2:{
    			trigger:{player:'phaseBegin'},
    			forced:true,
    			popup:false,
    			silent:true,
    			content:function(){
    				player.removeSkill('hsbaowu_huangjinyuanhou');
    				delete player.storage.hsbaowu_huangjinyuanhou;
    			}
    		},
    		xieneng:{
    			trigger:{player:'phaseEnd'},
    			direct:true,
    			content:function(){
    				'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:function(card,player,target){
    						if(card.name=='guiyoujie') return [0,1];
    					}
    				}
    			}
    		},
    		fbeifa:{
    			trigger:{player:'loseEnd'},
    			filter:function(event,player){
    				if(player.countCards('h')) return false;
    				if(player.storage.fbeifa>=3) return false;
    				for(var i=0;i<event.cards.length;i++){
    					if(event.cards[i].original=='h') return true;
    				}
    				return false;
    			},
    			direct:true,
    			content:function(){
    				"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);
    					player.storage.fbeifa++;
    				}
    			},
    			ai:{
    				expose:0.2,
    			},
    			group:['fbeifa2','fbeifa3'],
    		},
    		fbeifa2:{
    			trigger:{source:'damageAfter'},
    			forced:true,
    			popup:false,
    			filter:function(event){
    				return event.parent.parent.parent.name=='fbeifa';
    			},
    			content:function(){
    				player.draw();
    			}
    		},
    		fbeifa3:{
    			trigger:{global:'phaseBegin'},
    			forced:true,
    			silent:true,
    			popup:false,
    			content:function(){
    				player.storage.fbeifa=0;
    			}
    		},
    		yufa:{
    			trigger:{global:'phaseEnd'},
    			direct:true,
    			filter:function(event,player){
    				return player.storage.yufa==event.player;
    			},
    			content:function(){
    				'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:{
    				expose:0.1
    			}
    		},
    		yufa2:{
    			trigger:{player:'damageEnd'},
    			filter:function(event,player){
    				return event.source==_status.currentPhase&&event.source!=player;
    			},
    			popup:false,
    			forced:true,
    			silent:true,
    			content:function(){
    				player.storage.yufa=trigger.source;
    			}
    		},
    		yufa3:{
    			trigger:{global:'phaseBegin'},
    			popup:false,
    			forced:true,
    			silent:true,
    			content:function(){
    				player.storage.yufa=null;
    			}
    		},
    		bingyan:{
    			enable:'phaseUse',
    			usable:1,
    			filter:function(event,player){
    				if(!lib.card.chiyuxi||!lib.card.jingleishan) return false;
    				return player.countCards('he')>0;
    			},
    			filterTarget:function(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:function(card){
    				return 6-get.value(card);
    			},
    			multitarget:true,
    			content:function(){
    				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:function(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:function(){
    				'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,
    					filter:function(event){
    						return (get.type(event.card)=='trick'&&event.cards[0]&&event.cards[0]==event.card);
    					},
    					content:function(){
    						player.draw();
    					}
    				}
    			},
    			ai:{
    				threaten:1.5,
    				noautowuxie:true,
    			}
    		},
    		yuanzheng:{
    			trigger:{player:'useCardToBegin'},
    			direct:true,
    			filter:function(event,player){
    				return event.target&&event.target!=player&&get.distance(player,event.target)>1&&event.target.countCards('he')>0;
    			},
    			content:function(){
    				player.discardPlayerCard(trigger.target,get.prompt('yuanzheng',trigger.target),'hej').logSkill=['yuanzheng',trigger.target];
    			}
    		},
    		yuanzheng_old:{
    			trigger:{player:'useCardToBegin'},
    			direct:true,
    			filter:function(event,player){
    				if(event.getParent(2).name=='yuanzheng') return false;
    				return event.target&&event.target!=player&&get.distance(player,event.target,'attack')>1;
    			},
    			content:function(){
    				'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:function(player){
    				player.storage.byuhuo=false;
    			},
    			filter:function(event,player){
    				if(player.hp>0) return false;
    				if(player.storage.byuhuo) return false;
    				return true;
    			},
    			content:function(){
    				player.storage.byuhuo=true;
    				player.addSkill('byuhuo2');
    				player.maxHp=2;
    				player.hp=2;
    				player.update();
    				if(!player.isTurnedOver()){
    					player.turnOver();
    				}
    			},
    			ai:{
    				threaten:function(player,target){
    					if(!target.storage.byuhuo) return 0.6;
    				}
    			},
    			intro:{
    				content:function(storage,player){
    					if(storage){
    						if(player.hasSkill('byuhuo2')){
    							return '不能成为其他角色卡牌的目标；在下一准备阶段，对所有其他角色造成两点火焰伤害';
    						}
    						return '已发动';
    					}
    					else{
    						return '未发动';
    					}
    				}
    			}
    		},
    		byuhuo2:{
    			trigger:{player:'phaseBegin'},
    			forced:true,
    			content:function(){
    				'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:function(card,player,target){
                        if(player!=target) return false;
                    }
                }
    		},
    		yulu:{
    			enable:'phaseUse',
    			usable:1,
    			filterTarget:true,
    			selectTarget:[1,Infinity],
    			content:function(){
    				'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:function(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:function(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:function(){
    				'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:function(card){
    					if(get.type(card,'trick')=='trick') return false;
    				}
    			},
    			mark:true,
    			marktext:'瘴',
    			intro:{
    				content:'下个回合无法使用锦囊牌'
    			}
    		},
    		hannu:{
    			trigger:{player:'damageEnd'},
    			forced:true,
    			filter:function(event,player){
    				return player.countCards('h')>0;
    			},
    			content:function(){
    				'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:function(card,player,target){
    						if(get.tag(card,'damage')){
    							if(player.hasSkillTag('jueqing')) 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:function(){
    				var num=Math.floor(Math.random()*3);
    				if(num) player.draw(num);
    			},
    		},
    		hhudun:{
    			trigger:{global:'phaseBegin'},
    			forced:true,
    			filter:function(event,player){
    				return !player.hujia;
    			},
    			content:function(){
    				player.changeHujia();
    			},
    			group:'hhudun_hujia',
    			subSkill:{
    				hujia:{
    					trigger:{player:'damageZero'},
    					filter:function(event){
    						return event.hujia;
    					},
    					forced:true,
    					content:function(){
    						player.draw();
    					}
    				}
    			},
    			ai:{
    				threaten:function(player,target){
    					if(target.hujia){
    						return 0.5;
    					}
    					else{
    						return 2;
    					}
    				}
    			}
    		},
    		fenlie:{
    			audio:2,
    			forced:true,
    			trigger:{player:'gainAfter'},
    			filter:function(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:function(){
    				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:function(card){
    						if(card.name=='toulianghuanzhu'){
    							return [1,2];
    						}
    					}
    				}
    			}
    		},
    		nianfu:{
    			trigger:{source:'damageEnd',player:'damageEnd'},
    			forced:true,
    			filter:function(event,player){
    				if(player==event.source){
    					return event.player!=player&&event.player.countCards('e');
    				}
    				else{
    					return event.source&&event.source!=player&&event.source.countCards('e');
    				}
    			},
    			logTarget:function(event,player){
    				if(player==event.player){
    					return event.source;
    				}
    				else{
    					return event.player;
    				}
    			},
    			content:function(){
    				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:{
    				maxHandcard:function(player,num){
    					var hs=player.getCards('h');
    					for(var i=0;i<hs.length;i++){
    						if(get.type(hs[i])=='equip'){
    							num++;
    						}
    					}
    					return num;
    				},
    			},
    			trigger:{player:'phaseEnd'},
    			forced:true,
    			filter:function(event,player){
    				return player.countCards('h',{type:'equip'});
    			},
    			content:function(){
    				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:function(card,player){
    						if(_status.currentPhase!=player) return;
    						if(player.needsToDiscard(2)) return;
    						if(get.type(card)=='equip'&&player.getEquip(card)){
    							return [0,0,0,0];
    						}
    					}
    				},
    			}
    		},
    		shixu:{
    			group:['shixu_begin','shixu_end','shixu_discard'],
    			subSkill:{
    				begin:{
    					trigger:{global:'phaseUseBegin'},
    					forced:true,
    					popup:false,
    					silent:true,
    					content:function(){
    						trigger.player.storage.shixu_begin=get.time();
    					}
    				},
    				end:{
    					trigger:{global:'phaseUseEnd'},
    					forced:true,
    					popup:false,
    					silent:true,
    					filter:function(event,player){
    						return typeof event.player.storage.shixu_begin=='number';
    					},
    					content:function(){
    						trigger.player.storage.shixu=get.time()-trigger.player.storage.shixu_begin;
    						delete trigger.player.storage.shixu_begin;
    					}
    				},
    				discard:{
    					trigger:{global:'phaseEnd'},
    					forced:true,
    					check:function(event,player){
    						return get.attitude(player,event.player)<0;
    					},
    					filter:function(event,player){
    						return typeof event.player.storage.shixu=='number'&&
    							event.player.storage.shixu>3000&&event.player.countCards('he')>0&&event.player.isAlive();
    					},
    					content:function(){
    						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:function(event,player){
    				return event.skill!='jixuan';
    			},
    			content:function(){
    				player.draw();
    				player.insertPhase();
    			},
    			ai:{
    				threaten:1.8
    			},
    		},
    		qianghua:{
    			trigger:{player:'useCardAfter'},
    			filter:function(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:function(event,player){
    				if(get.tag({name:event.card.name},'norepeat')) return false;
    				return true;
    			},
    			content:function(){
    				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'},
    					forced:true,
    					silent:true,
    					popup:false,
    					content:function(){
    						player.storage.qianghua=0;
    					}
    				}
    			}
    		},
    		qianghua2:{},
    		biri:{
    			trigger:{global:'useCard'},
    			priority:15,
    			filter:function(event,player){
    				return event.card.name=='sha'&&event.player!=player&&
    					get.distance(player,event.targets[0])<=1&&
    					player.countCards('h','shan')>0&&
    					event.targets.contains(player)==false&&event.targets.length==1;
    			},
    			direct:true,
    			content:function(){
    				"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)+'失效？';
    				if(event.isMine()||effect<0){
    					game.delay(0.5);
    				}
    				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.logSkill=['biri',trigger.targets];
    				"step 1"
    				if(result.bool){
    					trigger.untrigger();
    					trigger.finish();
    				}
    			},
    			ai:{
    				expose:0.2
    			}
    		},
    		stuxi:{
    			trigger:{player:'phaseEnd'},
    			forced:true,
    			filter:function(event,player){
    				var enemies=player.getEnemies();
    				for(var i=0;i<enemies.length;i++){
    					if(!enemies[i].hasSkill('stuxi2')) return true;
    				}
    				return false;
    			},
    			content:function(){
    				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:function(event){
    				return event.num>0;
    			},
    			content:function(){
    				trigger.num--;
    				player.removeSkill('stuxi2');
    			}
    		},
    		bingdong:{
    			trigger:{source:'damageEnd'},
    			forced:true,
    			usable:1,
    			filter:function(event,player){
    				if(!lib.card.hslingjian_jinjilengdong){
    					return false;
    				}
    				return true;
    			},
    			content:function(){
    				player.gain(game.createCard('hslingjian_jinjilengdong'),'gain2');
    			}
    		},
    		bingdong_old:{
    			enable:'phaseUse',
    			usable:1,
    			filter:function(event,player){
    				return !player.isTurnedOver();
    			},
    			filterTarget:function(card,player,target){
    				return !target.isTurnedOver()&&player!=target;
    			},
    			content:function(){
    				'step 0'
    				if(!player.isTurnedOver()){
    					player.turnOver();
    				}
    				'step 1'
    				if(!target.isTurnedOver()){
    					target.turnOver();
    				}
    			},
    			ai:{
    				order:1,
    				expose:0.2,
    				result:{
    					target:function(player,target){
    						if(get.attitude(player,target)<-3&&player.identity!='zhu'){
    							return -1;
    						}
    						return 0;
    					}
    				}
    			}
    		},
    		luoshi:{
    			trigger:{player:'damageEnd'},
    			forced:true,
    			filter:function(event,player){
    				return player.countCards('he')>0||(event.source&&event.source.countCards('he')>0);
    			},
    			content:function(){
    				'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())
    					}
    				}
    			}
    		},
    		ronghuo:{
    			trigger:{player:'useCardToBefore'},
    			priority:7,
    			filter:function(event,player){
    				if(event.card.name=='sha'&&!event.card.nature) return true;
    			},
    			check:function(event,player){
    				var att=get.attitude(player,event.target);
    				if(event.target.hasSkillTag('nofire')){
    					return att>0;
    				}
    				return att<=0;
    			},
    			forced:true,
    			content:function(){
    				trigger.card.nature='fire';
    				player.addSkill('ronghuo2');
    				player.storage.ronghuo=trigger.card;
    			}
    		},
    		ronghuo2:{
    			trigger:{player:'useCardAfter'},
    			forced:true,
    			popup:false,
    			content:function(){
    				delete player.storage.ronghuo.nature;
    			}
    		},
    		fushi:{
    			enable:'phaseUse',
    			filterTarget:function(card,player,target){
    				return target.hp<target.maxHp;
    			},
    			content:function(){
    				'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:function(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;
    					}
    				}
    			}
    		},
    		mianyi:{
    			mod:{
    				targetEnabled:function(card,player,target,now){
    					if(player!=target){
    						if(get.type(card)=='trick') return false;
    					}
    				}
    			}
    		},
    		jiaohui:{
    			trigger:{player:'phaseEnd'},
    			direct:true,
    			filter:function(event,player){
    				return !player.getStat('damage');
    			},
    			content:function(){
    				'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);
    				}
    			},
    		},
    		chenshui:{
    			trigger:{player:'phaseEnd'},
    			frequent:true,
    			content:function(){
    				var list=['hsmengjing_feicuiyoulong','hsmengjing_huanxiaojiemei',
    					'hsmengjing_suxing','hsmengjing_mengye','hsmengjing_mengjing'];
    				player.gain(game.createCard(list.randomGet()));
    				player.$draw();
    			},
    			ai:{
    				threaten:2
    			}
    		},
    		liehun:{
    			trigger:{player:'phaseEnd'},
    			forced:true,
    			filter:function(event,player){
    				return player.hasCard(function(card){
    					return get.type(card)!='basic'&&!get.info(card).unique;
    				});
    			},
    			content:function(){
    				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:function(player,num){
    					if(player.hp<player.maxHp) return num+5;
    					return num+3;
    				},
    			},
    		},
    		malymowang:{
    			trigger:{source:'damageBegin'},
    			forced:true,
    			usable:1,
    			alter:true,
    			filter:function(event){
    				return event.card&&get.type(event.card)=='trick'&&event.parent.name!='_lianhuan'&&event.parent.name!='_lianhuan2';
    			},
    			content:function(){
    				trigger.num++;
    			},
    			group:'malymowang2',
    			ai:{
    				threaten:1.8
    			}
    		},
    		malymowang2:{
    			trigger:{player:'phaseUseBegin'},
    			forced:true,
    			content:function(){
    				'step 0'
    				if(get.is.altered('malymowang')){
    					player.gain(game.createCard(get.inpile('trick').randomGet()),'draw');
    					event.finish();
    					return;
    				}
    				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).ai=function(button){
    					var card={name:button.link[2]};
    					var value=get.value(card);
    					if(get.tag(card,'damage')) value++;
    					return value;
    				};
    				'step 1'
    				if(result.bool){
    					player.gain(game.createCard(result.buttons[0].link[2]),'draw');
    				}
    			}
    		},
    		lingzhou:{
    			trigger:{player:'useCard'},
    			direct:true,
    			filter:function(event){
    				return get.type(event.card,'trick')=='trick'&&event.cards[0]&&event.cards[0]==event.card;
    			},
    			content:function(){
    				"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:function(){
    				'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:function(event,player){
    				return !player.isTurnedOver();
    			},
    			content:function(){
    				"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:function(event,player){
    				if(get.is.altered('xshixin')&&event.player.hp<player.hp) return false;
    				return event.player.isAlive()&&event.player!=player;
    			},
    			content:function(){
    				'step 0'
    				trigger.player.loseHp();
    				'step 1'
    				player.loseHp();
    			}
    		},
    		enze:{
    			enable:'phaseUse',
    			usable:1,
    			filterTarget:function(card,player,target){
    				return player.countCards('h')!=target.countCards('h');
    			},
    			alter:true,
    			content:function(){
    				var num=player.countCards('h')-target.countCards('h');
    				if(num>0){
    					if(num>3){
    						num=3;
    					}
    					if(get.is.altered('enze')&&num>2){
    						num=2;
    					}
    					target.draw(num);
    				}
    				else if(num<0){
    					if(get.is.altered('enze')&&num<-2){
    						num=-2;
    					}
    					target.chooseToDiscard(-num,true);
    				}
    			},
    			ai:{
    				threaten:1.8,
    				order:function(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:function(player,target){
    						return (player.countCards('h')-target.countCards('h'))*get.attitude(player,target);
    					}
    				},
    				expose:0.2
    			}
    		},
    		chongsheng:{
    			unique:true,
    			enable:'chooseToUse',
    			mark:true,
    			init:function(player){
    				player.storage.chongsheng=2;
    				player.syncStorage('chongsheng');
    			},
    			filter:function(event,player){
    				if(event.type!='dying') return false;
    				if(player!=event.dying) return false;
    				if(player.storage.chongsheng<=0) return false;
    				return true;
    			},
    			content:function(){
    				'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:function(player){
    					if(player.storage.chongsheng<=0) return false;
    					if(player.hp>0) return false;
    				},
    				save:true,
    				result:{
    					player:10
    				},
    				threaten:function(player,target){
    					if(target.storage.chongsheng>0) return 0.6;
    				}
    			},
    			intro:{
    				content:'time'
    			}
    		},
    		guozai:{
    			enable:'phaseUse',
    			usable:1,
    			alter:true,
    			filter:function(event,player){
    				return player.countCards('h')<(get.is.altered('guozai')?3:4);
    			},
    			init:function(player){
    				player.storage.guozai2=0;
    			},
    			content:function(){
    				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:function(){
    				player.chooseToDiscard('he',true,player.storage.guozai2);
    				player.storage.guozai2=0;
    				player.removeSkill('guozai2');
    			}
    		},
    		guozaix:{
    			enable:'phaseUse',
    			usable:2,
    			filter:function(event,player){
    				return player.countCards('h')<4;
    			},
    			init:function(player){
    				player.storage.guozaix2=0;
    			},
    			content:function(){
    				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:function(){
    				player.chooseToDiscard('he',true,player.storage.guozaix2);
    				player.storage.guozaix2=0;
    				player.removeSkill('guozaix2');
    			}
    		},
    		hanshuang:{
    			trigger:{source:'damageEnd'},
    			forced:true,
    			alter:true,
    			filter:function(event,player){
    				return event.card&&get.color(event.card)=='black'&&
    				!event.player.isTurnedOver()&&event.player.isAlive();
    			},
    			content:function(){
    				trigger.player.turnOver();
    				if(get.is.altered('hanshuang')) trigger.player.draw();
    				player.loseHp();
    			},
    			ai:{
    				threaten:1.5,
    				effect:{
    					player:function(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:function(event,player){
    				return event.player.hasSkill('bingshi')&&event.player.isDead();
    			},
    			content:function(){
    				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:function(card,player,target){
    				return !target.storage.huanwu;
    			},
    			content:function(){
    				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:function(player,target){
    						return 1/target.hp;
    					}
    				},
    				order:10,
    				expose:0.3
    			}
    		},
    		fengnu:{
    			mod:{
    				cardUsable:function(card){
    					if(get.info(card)&&get.info(card).forceUsable) return;
    					return Infinity;
    				},
    				targetInRange:function(){
    					if(!get.is.altered('fengnu')) return true;
    				}
    			},
    			alter:true,
    			trigger:{player:'useCard'},
    			filter:function(event,player){
    				if(_status.currentPhase!=player) return false;
    				return get.cardCount(event.card,player)>1;
    			},
    			forced:true,
    			usable:3,
    			content:function(){
    				player.draw();
    			}
    		},
    		shengdun:{
    			trigger:{player:'phaseBegin'},
    			forced:true,
    			filter:function(event,player){
    				return !player.hujia;
    			},
    			content:function(){
    				player.changeHujia();
    				player.update();
    			},
    		},
    		shengdun_old:{
    			trigger:{player:'phaseBegin'},
    			forced:true,
    			silent:true,
    			popup:false,
    			priority:10,
    			init2:function(player){
    				player.markSkill('shengdun');
    			},
    			content:function(){
    				if(player.storage.shengdun){
    					player.markSkill('shengdun');
    				}
    				player.storage.shengdun=false;
    			},
    			intro:{
    				content:'未发动'
    			},
    			group:'shengdun2'
    		},
    		shengdun_old2:{
    			trigger:{player:'damageBegin'},
    			forced:true,
    			filter:function(event,player){
    				return event.num>0&&!player.storage.shengdun;
    			},
    			content:function(){
    				trigger.num--;
    				player.storage.shengdun=true;
    				player.unmarkSkill('shengdun');
    			}
    		},
    		jingmeng:{
    			trigger:{player:'useCard'},
    			frequent:true,
    			filter:function(event,player){
    				return _status.currentPhase==player&&get.cardCount(true,player)==1;
    			},
    			content:function(){
    				var type=get.type(trigger.card);
    				var card=get.cardPile(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:function(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:function(){
    				'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:function(event,player){
    				return get.cardCount(true,player)>0;
    			},
    			content:function(){
    				player.draw(get.cardCount(true,player));
    			},
    			ai:{
    				threaten:1.3
    			}
    		},
    		bingshuang:{
    			trigger:{source:'damageEnd'},
    			filter:function(event,player){
    				return event.card&&get.type(event.card)=='trick'&&
    				event.player.isAlive()&&!event.player.isTurnedOver();
    			},
    			check:function(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:function(){
    				trigger.player.draw(2);
    				trigger.player.turnOver();
    			}
    		},
    		yanshu:{
    			trigger:{player:'discardAfter'},
    			frequent:true,
    			usable:1,
    			filter:function(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:function(){
    				player.gain(game.createCard('liuxinghuoyu','red'),'gain2');
    			},
    		},
    		yanshu_old:{
    			enable:'phaseUse',
    			usable:1,
    			filter:function(event,player){
    				return player.countCards('h',{type:'basic'})<player.countCards('h');
    			},
    			filterCard:function(card){
    				return get.type(card)!='basic';
    			},
    			check:function(card){
    				return 6-get.value(card);
    			},
    			content:function(){
    				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:function(event,player){
    				return !player.hasSkill('shengyan2')&&event.player.hp<event.player.maxHp;
    			},
    			logTarget:'player',
    			check:function(event,player){
    				return get.attitude(player,event.player)>0;
    			},
    			content:function(){
    				trigger.player.recover();
    				player.addTempSkill('shengyan2','phaseAfter');
    			},
    			ai:{
    				expose:0.2
    			}
    		},
    		shengyan2:{},
    		liechao:{
    			enable:'phaseUse',
    			usable:1,
    			alter:true,
    			filter:function(event,player){
    				return !player.isTurnedOver()&&player.countCards('h')<=player.hp;
    			},
    			content:function(){
    				player.draw(get.is.altered('liechao')?3:4);
    				player.turnOver();
    				player.skip('phaseDiscard');
    			},
    			ai:{
    				order:10,
    				result:{
    					player:1
    				}
    			}
    		},
    		qingliu:{
    			trigger:{player:'damageBefore'},
    			filter:function(event){
    				return event.nature=='fire';
    			},
    			forced:true,
    			content:function(){
    				trigger.untrigger();
    				trigger.finish();
    			},
    			ai:{
    				nofire:true,
    				effect:{
    					target:function(card,player,target,current){
    						if(get.tag(card,'fireDamage')) return 0;
    					}
    				}
    			}
    		},
    		zhongjia:{
    			trigger:{player:'damageEnd'},
    			forced:true,
    			filter:function(event){
    				return event.num>0;
    			},
    			content:function(){
    				player.changeHujia();
    			},
    			ai:{
    				nohujia:true,
    				skillTagFilter:function(player){
    					return player.hp>player.countCards('h');
    				},
    				threaten:function(player,target){
    					if(!target.hujia) return 0.8;
    				},
    				effect:{
    					target:function(card,player){
    						if(get.tag(card,'damage')){
    							if(player.hasSkillTag('jueqing')) return [1,-1];
    							return 0.8;
    						}
    					}
    				}
    			}
    		},
    		dunji:{
    			enable:'phaseUse',
    			usable:1,
    			filter:function(event,player){
    				return player.hujia?true:false;
    			},
    			filterTarget:function(card,player,target){
    				return player!=target;
    			},
    			selectTarget:function(){
    				return [1,_status.event.player.hujia];
    			},
    			contentBefore:function(){
    				player.changeHujia(-player.hujia);
    			},
    			content:function(){
    				target.damage();
    			},
    			ai:{
    				order:9,
    				result:{
    					target:function(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:function(event,player){
    				return _status.currentPhase!=player&&!player.hasSkill('fengxing2')&&player.countCards('he')>0;
    			},
    			content:function(){
    				'step 0'
    				if(!event.isMine()) game.delay(0.5);
    				'step 1'
    				player.addTempSkill('fengxing2','phaseAfter');
    				player.chooseToDiscard('he',get.prompt('fengxing')).set('ai',function(card){
    					return 7-get.value(card);
    				}).logSkill='fengxing';
    				'step 2'
    				if(result.bool){
    					player.draw(2);
    				}
    			},
    			ai:{
    				threaten:0.6
    			}
    		},
    		fengxing2:{},
    		fengxian:{
    			enable:'phaseUse',
    			usable:1,
    			filterTarget:function(card,player,target){
    				return target.countCards('h')>0;
    			},
    			selectTarget:-1,
    			content:function(){
    				target.chooseToDiscard(true);
    			},
    			ai:{
    				order:8,
    				result:{
    					target:function(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:['chooseToRespond'],
    			filterCard:{type:'equip'},
    			filter:function(event,player){
    				return player.countCards('he',{type:'equip'})>0;
    			},
    			viewAs:{name:'shan'},
    			position:'he',
    			prompt:'将一张装备牌当闪使用或打出',
    			check:function(){return 1},
    			ai:{
    				respondShan:true,
    				skillTagFilter:function(player){
    					if(!player.countCards('he',{type:'equip'})) return false;
    				}
    			}
    		},
    		hsmengjing_mengye:{
    			trigger:{player:'phaseEnd'},
    			forced:true,
    			priority:-1,
    			filter:function(event,player){
    				return player.countCards('he')>0;
    			},
    			content:function(){
    				player.discard(player.getCards('he'));
    				player.removeSkill('hsmengjing_mengye');
    			},
    			mark:'image',
    			intro:{
    				content:'结束阶段，弃置所有牌'
    			}
    		},
    		zhanhou:{
    			enable:'phaseUse',
    			filterCard:{subtype:'equip2'},
    			position:'he',
    			filter:function(event,player){
    				return player.countCards('he',{subtype:'equip2'})>0;
    			},
    			check:function(card){
    				return 7-get.value(card);
    			},
    			content:function(){
    				player.changeHujia();
    			},
    			ai:{
    				order:9.5,
    				result:{
    					player:1
    				}
    			},
    			// mod:{
    			// 	globalFrom:function(from,to,distance){
    			// 		return distance-from.hujia;
    			// 	}
    			// },
    		},
    		shijie:{
    			trigger:{player:'phaseEnd'},
    			direct:true,
    			filter:function(event,player){
    				return game.hasPlayer(function(current){
    					return current!=player&&current.countCards('h');
    				});
    			},
    			content:function(){
    				'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:function(event,player){
    				return player.countCards('he',{color:'red'})>0;
    			},
    			position:'he',
    			usable:1,
    			check:function(card){
    				return 9-get.value(card)
    			},
    			filterTarget:function(card,player,target){
    				if(player.storage.anying) return true;
    				if(target.hp>=target.maxHp) return false;
    				return true;
    			},
    			content:function(){
    				if(player.storage.anying){
    					target.loseHp();
    				}
    				else{
    					target.recover();
    				}
    			},
    			ai:{
    				order:9,
    				result:{
    					target:function(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:function(event,player){
    				return player.countCards('he',{color:'black'})>0;
    			},
    			position:'he',
    			usable:1,
    			mark:true,
    			intro:{
    				content:'已进入暗影形态'
    			},
    			check:function(card){
    				return 9-get.value(card)
    			},
    			filterTarget:true,
    			content:function(){
    				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:function(event,player){
    				return !player.storage.anying&&player.countCards('he',{color:'black'})>1;
    			},
    			filterCard:{color:'black'},
    			position:'he',
    			check:function(card){
    				return 5-get.value(card);
    			},
    			content:function(){
    				player.storage.anying=true;
    				player.awakenSkill('anying');
    				player.removeSkill('shengguang');
    				player.addSkill('xinci');
    			},
    			ai:{
    				order:1,
    				result:{
    					player:function(player){
    						if(player.hasUnknown()) return 0;
    						return !game.hasPlayer(function(current){
    							return get.attitude(player,current)>0&&current.isDamaged()&&current.hp<=2;
    						});
    					}
    				}
    			}
    		},
    		huanjue:{
    			trigger:{global:'useCard'},
                usable:1,
    			filter:function(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:function(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:function(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);
                },
    			content:function(){
                    '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.delay();
    					trigger.untrigger();
    					trigger.card=card;
    					trigger.cards=[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.delay(0.5);
    				'step 3'
    				trigger.trigger('useCard');
    			},
    			ai:{
    				expose:0.2,
    				threaten:function(player,target){
                        if(target.storage.counttrigger&&target.storage.counttrigger.huanjue) return 1.8;
                        return 0.6;
                    },
                    effect:{
                        target:function(player,target){
                            if(player!=target&&_status.currentPhase==target) return 0;
                        }
                    }
    			}
    		},
    		bingjia:{
    			enable:'phaseUse',
    			filter:function(event,player){
    				return !player.hasSkill('bingjia2');
    			},
    			filterCard:true,
    			check:function(card){
    				return 6-get.value(card);
    			},
    			discard:false,
    			prepare:function(cards,player){
    				player.$give(1,player,false);
    			},
    			content:function(){
    				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:function(event,player){
    				return event.player!=player&&get.suit(event.card)==get.suit(player.storage.bingjia);
    			},
    			content:function(){
    				'step 0'
    				player.showCards([player.storage.bingjia],get.translation(player)+'发动了【冰甲】');
    				player.removeSkill('bingjia2');
    				game.addVideo('storage',player,['bingjia',null]);
    				'step 1'
    				ui.discardPile.appendChild(player.storage.bingjia);
    				delete player.storage.bingjia;
    				player.changeHujia();
    				player.addTempSkill('bingjia3','phaseAfter');
    			},
    			intro:{
    				mark:function(dialog,content,player){
    					if(player==game.me||player.isUnderControl()){
    						dialog.add([player.storage.bingjia]);
    					}
    					else{
    						return '已发动冰甲';
    					}
    				},
    				content:function(content,player){
    					if(player==game.me||player.isUnderControl()){
    						return get.translation(player.storage.bingjia);
    					}
    					return '已发动冰甲';
    				}
    			}
    		},
    		bingjia3:{
    			trigger:{player:'damageBefore'},
    			mark:true,
    			forced:true,
    			content:function(){
    				trigger.untrigger();
    				trigger.finish();
    			},
    			ai:{
    				nofire:true,
    				nothunder:true,
    				nodamage:true,
    				effect:{
    					target:function(card,player,target,current){
    						if(get.tag(card,'damage')) return [0,0];
    					}
    				},
    			},
    			intro:{
    				content:'防止所有伤害'
    			}
    		},
    		bianxing2:{},
    		zuzhou:{
    			trigger:{player:'phaseBegin'},
    			filter:function(event,player){
    				if(!player.countCards('h',{suit:'spade'})) return false;
    				return !game.hasPlayer(function(current){
    					return current.hasJudge('shandian');
    				});
    			},
    			forced:true,
    			check:function(){
    				return false;
    			},
    			content:function(){
    				'step 0'
    				var card=get.cardPile('shandian',true);
    				if(card){
    					player.addJudge(card);
    					player.$draw(card);
    					game.delay();
    				}
    				else{
    					event.finish();
    				}
    				'step 1'
    				game.delay();
    			},
    			ai:{
    				threaten:1.5
    			}
    		},
    		mdzhoufu:{
    			enable:'phaseUse',
    			filterCard:{color:'black'},
    			filter:function(event,player){
    				return player.countCards('h',{color:'black'})>0;
    			},
    			filterTarget:function(card,player,target){
    				return player!=target&&!target.hasSkill('mdzhoufu2');
    			},
    			prepare:'throw',
    			discard:false,
    			content:function(){
    				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:function(card){
    				if(get.suit(card)=='spade'&&card.number>=2&&card.number<=9){
    					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:function(){
    				"step 0"
    				ui.discardPile.appendChild(player.storage.mdzhoufu2);
    				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.isAlive()){
    					// player.storage.mdzhoufu3.draw();
    					player.storage.mdzhoufu3.gain(player.judging[0]);
    					player.storage.mdzhoufu3.$gain2(player.judging[0]);
    				}
    				else{
    					ui.discardPile.appendChild(player.judging[0]);
    					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:function(event,player){
    				var target=(player==event.player)?event.source:event.player;
    				return get.attitude(player,target)<0;
    			},
    			filter:function(event,player){
    				var target=(player==event.player)?event.source:event.player;
    				return target.isAlive();
    			},
    			prompt:function(event,player){
    				var target=(player==event.player)?event.source:event.player;
    				return get.prompt('zuzhou',target);
    			},
    			content:function(){
    				"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:function(){
    				return ui.cardPile.childNodes.length>1;
    			},
    			check:function(){
    				return false;
    			},
    			content:function(){
    				'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:function(event,player){
    				if(event.responded) return false;
    				return game.hasPlayer(function(current){
    					return current!=player&&current.countCards('h');
    				});
    			},
    			content:function(){
    				"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:{
    				effect:{
    					target:function(card){
    						if(get.tag(card,'respondShan')) return 0.4;
    						if(get.tag(card,'respondSha')) return 0.4;
    					}
    				}
    			},
    		},
    		wlianji:{
    			trigger:{player:'phaseEnd'},
    			frequent:true,
    			filter:function(event,player){
    				return get.cardCount(true,player)>player.hp;
    			},
    			content:function(){
    				player.draw(2);
    			},
    			init:function(player){player.storage.jingce=true},
    			intro:{
    				content:function(storage,player){
    					if(_status.currentPhase==player) return '已使用'+get.cardCount(true,player)+'张牌';
    				}
    			}
    		},
    		mengun:{
    			trigger:{global:'useCardToBefore'},
    			priority:12,
    			filter:function(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:function(){
    				"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.untrigger();
    					trigger.finish();
    					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:function(card,player){
    					if(card==player.storage.mengun2) return false;
    				},
    			},
    			intro:{
    				content:'card',
    				onunmark:function(storage,player){
    					delete player.storage.mengun2;
    				}
    			},
    		},
    		jianren:{
    			enable:'phaseUse',
    			usable:1,
    			filter:function(event,player){
    				return player.getEquip(1)?true:false;
    			},
    			filterCard:function(card,player){
    				return card==player.getEquip(1);
    			},
    			position:'e',
    			filterTarget:function(card,player,target){
    				return target!=player;
    			},
    			selectCard:-1,
    			selectTarget:-1,
    			content:function(){
    				target.damage();
    			},
    			ai:{
    				order:9,
    				result:{
    					target:function(player,target){
    						return get.damageEffect(target,player,target);
    					}
    				}
    			}
    		},
    		jihuo:{
    			trigger:{player:'phaseAfter'},
    			filter:function(event,player){
    				return player.countCards('h')>0&&event.skill!='jihuo';
    			},
    			direct:true,
    			priority:-50,
    			content:function(){
    				"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:function(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:function(){
    				"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','phaseAfter');
    				}
    			},
    			ai:{
    				threaten:1.2,
    				expose:0.3,
    				effect:{
    					target:function(card,player,target){
    						if(get.tag(card,'loseCard')&&target.countCards('he')){
    							return 0.7;
    						}
    					}
    				},
    			}
    		},
    		tzhenji2:{},
    		tzhenji_old:{
    			trigger:{player:['useCard','respondEnd']},
    			filter:function(event){
    				return get.suit(event.card)=='spade';
    			},
    			direct:true,
    			content:function(){
    				"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:function(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:function(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:function(){
    				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:function(card,player){
    					if(get.tag(card,'damage')){
    						if(player.hasSkillTag('jueqing')) return [1,1];
    						return 1.2;
    					}
    				},
    				threaten:1.3
    			},
    			group:'tuteng_lose'
    		},
    		s_tuteng:{
    			trigger:{player:'phaseBegin'},
    			forced:true,
    			unique:true,
    			content:function(){
    				var rand=['tuteng1','tuteng2','tuteng3','tuteng4','tuteng5','tuteng6','tuteng7','tuteng8'];
    				var rand2=[];
    				for(var i=0;i<rand.length;i++){
    					if(player.skills.contains(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:function(){
    				for(var i=1;i<=8;i++){
    					lib.translate['tuteng'+i+'_info']=lib.skill['tuteng'+i].intro.content;
    				}
    			},
    			position:'he',
    			filter:function(event,player){
    				var rand=['tuteng1','tuteng2','tuteng3','tuteng4'];
    				for(var i=0;i<rand.length;i++){
    					if(!player.hasSkill(rand[i])) return true;
    				}
    				return false;
    			},
    			content:function(){
    				'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.contains(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.contains(current)){
    										return rand2.contains(button.name);
    									}
    									else{
    										return rand.contains(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.contains('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:function(card,player){
    					if(get.tag(card,'damage')){
    						if(player.hasSkillTag('jueqing')) return;
    						return 1.2;
    					}
    				},
    				threaten:2
    			},
    			group:'tuteng_lose'
    		},
    		zuling:{
    			skillAnimation:'epic',
    			animationColor:'thunder',
    			trigger:{player:'phaseBegin'},
    			forced:true,
    			unique:true,
    			filter:function(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.contains(player.skills[i])) num++;
    						if(num>=2){
    							return true;
    						}
    					}
    				}
    				return false;
    			},
    			content:function(){
    				player.storage.tuteng_awake=true;
    				player.loseMaxHp();
    				player.awakenSkill('zuling');
    			}
    		},
    		tuteng_h:{
    			mod:{
    				maxHandcard:function(player,num){
    					return num-1;
    				}
    			}
    		},
    		tuteng_lose:{
    			trigger:{player:'damageEnd'},
    			forced:true,
    			popup:false,
    			filter:function(event,player){
    				var tuteng=['tuteng1','tuteng2','tuteng3','tuteng4',
    				'tuteng5','tuteng6','tuteng7','tuteng8'];
    				for(var i=0;i<player.skills.length;i++){
    					if(tuteng.contains(player.skills[i])) return true;
    				}
    				return false;
    			},
    			content:function(){
    				var tuteng=['tuteng1','tuteng2','tuteng3','tuteng4',
    				'tuteng5','tuteng6','tuteng7','tuteng8'];
    				var rand=[];
    				for(var i=0;i<player.skills.length;i++){
    					if(tuteng.contains(player.skills[i])){
    						rand.push(player.skills[i]);
    					}
    				}
    				if(rand.length){
    					player.removeSkill(rand.randomGet());
    				}
    			}
    		},
    		tuteng1:{
    			mark:'image',
    			nopop:true,
    			intro:{
    				content:'结束阶段，你回复一点体力'
    			},
    			trigger:{player:'phaseEnd'},
    			forced:true,
    			filter:function(event,player){
    				return player.hp<player.maxHp;
    			},
    			content:function(){
    				player.recover();
    			}
    		},
    		tuteng2:{
    			mark:'image',
    			nopop:true,
    			intro:{
    				content:'每当你造成一次伤害，你摸一张牌'
    			},
    			trigger:{source:'damageAfter'},
    			forced:true,
    			content:function(){
    				player.draw();
    			}
    		},
    		tuteng3:{
    			mark:'image',
    			nopop:true,
    			intro:{
    				content:'你受到下一次伤害时，令伤害-1，然后失去此图腾'
    			},
    			trigger:{player:'damageBegin'},
    			forced:true,
    			filter:function(event){
    				return event.num>0;
    			},
    			content:function(){
    				trigger.num--;
    				player.removeSkill('tuteng3');
    			},
    		},
    		tuteng4:{
    			mark:'image',
    			nopop:true,
    			intro:{
    				content:'在你的回合内，你的锦囊牌造成的首次伤害+1'
    			},
    			trigger:{source:'damageBegin'},
    			forced:true,
    			usable:1,
    			filter:function(event,player){
    				return _status.currentPhase==player&&event.card&&get.type(event.card)=='trick'&&event.notLink();
    			},
    			content:function(){
    				trigger.num++;
    			}
    		},
    		tuteng5:{
    			mark:'image',
    			nopop:true,
    			intro:{
    				content:'结束阶段，你摸一张牌'
    			},
    			trigger:{player:'phaseEnd'},
    			forced:true,
    			content:function(){
    				player.draw();
    			}
    		},
    		tuteng6:{
    			mark:'image',
    			nopop:true,
    			intro:{
    				content:'在你的回合内，你的杀造成的首次伤害+1'
    			},
    			trigger:{source:'damageBegin'},
    			forced:true,
    			filter:function(event,player){
    				return _status.currentPhase==player&&event.card&&event.card.name=='sha'&&event.notLink();
    			},
    			usable:1,
    			content:function(){
    				trigger.num++;
    			}
    		},
    		tuteng7:{
    			mark:'image',
    			nopop:true,
    			intro:{
    				content:'结束阶段，你令一名其他角色回复一点体力'
    			},
    			trigger:{player:'phaseEnd'},
    			direct:true,
    			filter:function(event,player){
    				return game.hasPlayer(function(current){
    					return current!=player&&current.isDamaged();
    				});
    			},
    			content:function(){
    				'step 0'
    				player.chooseTarget('活力图腾：令一名其他角色回复一点体力',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:function(from,to,distance){
    					return distance-1;
    				}
    			}
    		},
    		fenliu:{
    			enable:'phaseUse',
    			prompt:'流失1点体力并摸三张牌',
    			usable:1,
    			content:function(){
    				"step 0"
    				player.loseHp(1);
    				"step 1"
    				player.draw(3);
    			},
    			ai:{
    				order:4,
    				result:{
    					player:function(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:function(card){
    						if(get.tag(card,'damage')||get.tag(card,'loseHp')){
    							return 1.5;
    						}
    					}
    				},
    				threaten:1.2
    			}
    		},
    		fenliu2:{
    			mod:{
    				maxHandcard:function(player,num){
    					return num+1;
    				}
    			}
    		},
    		hongxi:{
    			trigger:{global:'dieAfter'},
    			filter:function(event,player){
    				return player.hp<player.maxHp;
    			},
    			forced:true,
    			content:function(){
    				player.recover(player.maxHp-player.hp);
    			},
    			ai:{
    				threaten:1.2
    			}
    		},
    	},
    	cardType:{
    		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:{
            hsjixie_zhadan:{
                enable:true,
				fullimage:true,
				type:'hsjixie',
    			vanish:true,
    			derivation:'hs_pengpeng',
				filterTarget:function(card,player,target){
					return target==player;
				},
				modTarget:true,
				selectTarget:-1,
                cardcolor:'black',
				content:function(){
					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:function(card,player,target){
                    return target==player;
                },
                selectTarget:-1,
                content:function(){
                    '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.animate('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:function(event,player){
                    return player.isDamaged();
                },
    			derivation:'hs_kalimosi',
                filterTarget:function(card,player,target){
                    return target==player;
                },
                selectTarget:-1,
                content:function(){
                    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:function(){
                    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:function(card,player,target){
                    return target!=player
                },
                selectTarget:[1,Infinity],
                content:function(){
                    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:function(card,player,target){
    				return target.countCards('he')>0;
    			},
    			content:function(){
    				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:function(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:function(){
    				target.gainMaxHp();
    				target.draw();
    			},
    			ai:{
    				order:5,
    				useful:3,
    				value:4,
    				result:{
    					target:function(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:function(){
    				target.changeHujia();
    			},
    			ai:{
    				order:5,
    				useful:3,
    				value:6,
    				result:{
    					target:function(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:function(){
    				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:function(){
    				player.draw();
    			},
    			ai:{
    				order:9,
    				useful:5,
    				value:4
    			}
    		},
    		hsdusu_xueji:{
    			type:'hsdusu',
    			fullimage:true,
    			vanish:true,
    			enable:true,
    			derivation:'hs_xialikeer',
    			filterTarget:function(card,player,target){
    				return target.countCards('e')>0;
    			},
    			content:function(){
    				target.discard(target.getCards('e').randomGets(2));
    			},
    			ai:{
    				order:5,
    				result:{
    					target:function(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:function(card,player,target){
    				return !target.hasSkill('qianxing');
    			},
    			content:function(){
    				target.addTempSkill('qianxing',{player:'phaseBegin'});
    			},
    			ai:{
    				order:2,
    				result:{
    					target:function(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:function(card,player,target){
    				return target==player;
    			},
    			selectTarget:-1,
    			modTarget:true,
    			content:function(){
    				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:function(){
    				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:function(card,player,target){
    				return !target.hasSkill('hsdusu_shinancao');
    			},
    			content:function(){
    				target.addSkill('hsdusu_shinancao');
    			},
    			ai:{
    				order:7,
    				result:{
    					target:function(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,
                gainnable:false,
    			derivation:'hs_yelise',
    			filterTarget:function(card,player,target){
    				return target==player;
    			},
    			selectTarget:-1,
    			content:function(){
    				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,
                gainnable:false,
    			derivation:'hs_yelise',
    			filterTarget:function(card,player,target){
    				return target==player;
    			},
    			selectTarget:-1,
    			content:function(){
                    '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.gainnable==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.addTempSkill('qianxing',{player:'phaseBegin'});
    			},
    			ai:{
    				order:10,
    				result:{
    					player:function(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:function(card,player){
    				return !player.isTurnedOver();
    			},
    			derivation:'hs_lafamu',
    			filterTarget:true,
    			content:function(){
    				target.gainMaxHp();
    				target.recover();
    				target.draw(4);
    			},
    			contentAfter:function(){
    				if(!player.isTurnedOver()){
    					player.turnOver();
    				}
    			},
    			ai:{
    				order:5,
    				result:{
    					target:function(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:function(card,player){
    				return !player.isTurnedOver();
    			},
    			derivation:'hs_lafamu',
    			filterTarget:function(card,player,target){
    				return target!=player;
    			},
    			selectTarget:-1,
    			content:function(){
    				target.damage(Math.ceil(Math.random()*2));
    			},
    			contentAfter:function(){
    				if(!player.isTurnedOver()){
    					player.turnOver();
    				}
    			},
    			ai:{
    				order:9,
    				result:{
    					target:-2
    				},
    				tag:{
    					damage:2,
    					multitarget:1,
    					multineg:1,
    				},
    				useful:5,
    				value:10,
    			}
    		},
    		hsshenqi_morijingxiang:{
    			type:'hsshenqi',
    			fullimage:true,
    			vanish:true,
    			enable:function(card,player){
    				return !player.isTurnedOver();
    			},
    			derivation:'hs_lafamu',
    			filterTarget:function(card,player,target){
    				return target!=player&&target.countCards('hej')>0;
    			},
    			selectTarget:-1,
    			content:function(){
    				if(target.countCards('hej')) player.gainPlayerCard(target,'hej',true,Math.ceil(Math.random()*2));
    			},
    			contentAfter:function(){
    				if(!player.isTurnedOver()){
    					player.turnOver();
    				}
    			},
    			ai:{
    				order:9.5,
    				result:{
    					player:1
    				},
    				tag:{
    					multitarget:1,
    					multineg:1,
    				},
    				useful:5,
    				value:10,
    			}
    		},
    		hsmengjing_feicuiyoulong:{
    			type:'hsmengjing',
    			fullimage:true,
    			vanish:true,
    			enable:true,
    			derivation:'hs_ysera',
    			filterTarget:true,
    			content:function(){
    				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:function(card,player,target){
    				return player!=target;
    			},
    			selectTarget:-1,
    			content:function(){
    				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:function(){
    				target.draw();
    				target.addSkill('hsmengjing_mengye');
    			},
    			ai:{
    				order:1,
    				useful:5,
    				value:10,
    				result:{
    					target:function(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:function(card,player,target){
    				return !target.hasJudge('lebu')||target.countCards('e')>0;
    			},
    			content:function(){
    				'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:function(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:function(card,player,target){
    				return target.hp<target.maxHp;
    			},
    			content:function(){
    				target.recover();
    			},
    			ai:{
    				order:6,
    				value:10,
    				useful:[7,4],
    				result:{
    					target:function(player,target){
    						return get.recoverEffect(target,player,target);
    					}
    				}
    			}
    		},
    		tuteng1:{
    			noname:true,
    			fullimage:true,
    			type:'hstuteng',
    			derivation:'hs_sthrall',
                gainnable:false
    		},
    		tuteng2:{
    			noname:true,
    			fullimage:true,
    			type:'hstuteng',
    			derivation:'hs_sthrall',
                gainnable:false
    		},
    		tuteng3:{
    			noname:true,
    			fullimage:true,
    			type:'hstuteng',
    			derivation:'hs_sthrall',
                gainnable:false
    		},
    		tuteng4:{
    			noname:true,
    			fullimage:true,
    			type:'hstuteng',
    			derivation:'hs_sthrall',
                gainnable:false
    		},
    		tuteng5:{
    			noname:true,
    			fullimage:true,
    			type:'hstuteng',
    			derivation:'hs_sthrall',
                gainnable:false
    		},
    		tuteng6:{
    			noname:true,
    			fullimage:true,
    			type:'hstuteng',
    			derivation:'hs_sthrall',
                gainnable:false
    		},
    		tuteng7:{
    			noname:true,
    			fullimage:true,
    			type:'hstuteng',
    			derivation:'hs_sthrall',
                gainnable:false
    		},
    		tuteng8:{
    			noname:true,
    			fullimage:true,
    			type:'hstuteng',
    			derivation:'hs_sthrall',
                gainnable: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_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:'图腾魔像',

            ysjqisha:'七煞',
            ysjqisha_ju:'惧之煞',
            ysjqisha_kuang:'狂之煞',
            ysjqisha_nu:'怒之煞',
            ysjqisha_yi:'疑之煞',
            ysjqisha_wang:'惘之煞',
            ysjqisha_hen:'恨之煞',
            ysjqisha_ao:'傲之煞',
            ysjqisha_info:'锁定技，每当你造成或受到伤害，你令对方随机获得一种消极状态直到下一回合结束',
            zhaochao:'招潮',
            zhaochao_info:'锁定技，结束阶段，你视为对一名随机敌人使用一张杀；若此杀被闪避，你视为对另一名随机敌人使用一张杀',
            hllingxi:'灵息',
            hllingxi_info:'出牌阶段，你可以令一名已受伤的其他角色弃置两张牌并回复一点体力；结束阶段，你可以回复一点体力',
            xiyong:'汐涌',
            xiyong_info:'结束阶段，你可以摸一张牌并可以使用之，若你使用了此牌，你再摸一张牌',
            hsjixie:'机械',
            hsjixie_zhadan:'炸弹机器人',
            hsjixie_zhadan_pop:'炸弹',
            hsjixie_zhadan_info:'出牌阶段对自己使用，对一名随机敌人造成一点火属性伤害',
            yindan:'引弹',
            yindan_info:'出牌阶段限一次，你可以弃置一张黑桃牌并流失一点体力，然后获得两张炸弹机器人',
            huanjue:'幻觉',
            huanjue_info:'每名角色的回合限一次，当你使用卡牌指定其他角色为惟一目标，或当其他角色使用卡牌指定你为惟一目标时，你可以从三张随机亮出的牌中选择一张代替此牌',
            yinzong:'影踪',
            yinzong_info:'锁定技，每当你失去装备区内牌，你获得潜行直到下一回合开始',
            tansuo:'探索',
            tansuo_info:'出牌阶段限一次，你可以弃置一张牌，然后随机获得一张炉石衍生牌',
            srjici:'棘刺',
            srjici_info:'锁定技，每当你造成一次伤害，你摸一张牌，受伤害角色随机弃置一张牌',
            lieqi:'猎奇',
            lieqi_info:'准备和结束阶段，你可以指定一名角色，从一张该角色手牌与另外两张随机牌中猜测哪张为该角色手牌，若猜中，你获得一张该牌的复制（同一回合不能指定相同角色）',
            azaowu:'造物',
            azaowu_backup:'造物',
            azaowu_info:'出牌阶段限一次，你可以将一张基本牌当作任意一张基本牌使用',
            shouwang:'守望',
            shouwang2:'守望',
            shouwang_info:'每名角色每局限一次，当一名角色进入濒死状态时，你可以令其回复一点体力并获得一点护甲',
            shouwang_info_alter:'每名角色每局限一次，当一名角色进入濒死状态时，你可以令其回复一点体力',
            qingtian:'擎天',
            qingtian_info:'锁定技，若你的体力值大于0，你防止即将回复的体力，改为获得等量护甲',
            qianfu:'潜伏',
            qianfu2:'潜伏',
            qianfu2_bg:'伏',
            qianfu_info:'锁定技，在你死亡前，若你没有进入潜伏状态，你弃置所有牌并进入潜伏状态；当你体力值回复到3（或体力上限）时，你解除潜伏状态并摸3张牌',
            shimo:'尸魔',
            shimo_info:'锁定技，距离你为1的角色受到伤害时，你回复一点体力，若你没受伤，改为摸一张牌',
            lieyang:'裂阳',
            lieyang_info:'锁定技，每当你于回合内使用一张锦囊牌，你获得一张随机锦囊牌；当你发动三次此技能后，你本回合不能再使用锦囊牌',
            zhuilie:'追猎',
            zhuilie_info:'准备阶段，你可以弃置一张牌，然后将牌堆顶6张牌中的基本牌移至弃牌堆；若移入弃牌堆的牌超过3张，你摸一张牌',
            szbianshen:'变身',
            szbianshen_info:'限定技，回合开始时，若游戏轮数不少于3，你可以随机观看5张体力上限不小于5的武将牌，将武将牌替换为其中一张',
            kekao:'科考',
            kekao_info:'结束阶段，你可以从三张随机亮出的延时锦囊牌中选择一张加入手牌',
            jinhua:'进化',
            jinhua_info:'锁定技，每当你以自己为目标使用一张非转化的锦囊牌，你从三个随机亮出的技能中选一个获得之',
            hsqizhou:'祈咒',
            hsqizhou_feng:'风之祈咒',
            hsqizhou_feng_info:'出牌阶段对自己使用，令所有目标的敌人打出一张杀或受到一点雷属性伤害',
            hsqizhou_shui:'水之祈咒',
            hsqizhou_shui_info:'出牌阶段对自己使用，回复两点体力',
            hsqizhou_huo:'火之祈咒',
            hsqizhou_huo_info:'出牌阶段对任意角色使用，令目标受到一点火属性伤害',
            hsqizhou_tu:'土之祈咒',
            hsqizhou_tu_info:'出牌阶段对任意其他角色使用，令目标获得一点护甲',
            kqizhou:'祈咒',
            kqizhou_info:'准备阶段，若你于上回合使用过锦囊牌，则可以获得一张元素祈咒',
            jingcu:'晶簇',
            jingcu_info:'出牌阶段，你可以减少一点体力上限并摸两张牌',
            shengzhang:'生长',
            shengzhang_info:'锁定技，若你于弃牌阶段弃置了牌，你增加一点体力上限',
            pyuhuo:'浴火',
            pyuhuo_info:'锁定技，在你首次进入濒死状态时，你弃置所有牌、重置武将牌、将体力和体力上限变为4并摸4张牌；在你第二次进入濒死状态时，你弃置所有牌、重置武将牌、将体力和体力上限变为6并摸6张牌',
            mengye:'梦魇',
            mengye_info:'结束阶段，你可以选择一名有手牌的角色将其一张随机的非毒手牌转化为毒，然后令其获得一点护甲',
    		mengye_old:'梦魇',
    		mengye_old2:'梦魇',
    		mengye_old_info:'回合结束后，你可以翻面并指定一名的非主公角色，由你控制其进行一个额外的回合。在此回合中，你的本体不参与游戏',
    		fuhua:'腐化',
    		fuhua2:'腐化',
    		fuhua_info:'出牌阶段，你可以将一张毒交给一名没有魔血技能的其他角色，该角色选择一项：1. 获得技能魔血，此后每个出牌阶段开始时需交给你一张牌；2. 视为你对其使用一张决斗，若你因此受到伤害，本局不能再对其发动腐化',
    		moxie:'魔血',
    		moxie2:'魔血',
    		moxie_info:'锁定技，你失去毒时不流失体力；你使用毒时摸两张牌；结束阶段，你将一张随机手牌转化为毒',
    		gfuhun:'附魂',
    		gfuhun_info:'结束阶段，若你未翻面，你可以和一名其他角色拼点，若你赢，你将武将牌翻至背面，该角色进入混乱状态直到下一回合结束',
    		longyi:'龙裔',
    		longyi_info:'锁定技，你的黑色牌不占用手牌上限',
    		zhongji:'重击',
    		zhongji_info:'每当你即将造成伤害，可弃置一张黑色手牌令伤害+1',
    		fuwen:'符文',
    		fuwen_info:'若你弃牌阶段弃置了锦囊牌，你可以获得一点护甲',
    		jinzhou:'禁咒',
    		jinzhou_info:'结束阶段，若你手牌中有黑桃牌，你可以令一名其他角色的非锁定技失效直到其下一回合结束',
    		midian:'秘典',
    		midian_info:'出牌阶段限一次，你可以弃置一张锦囊牌，然后随机获得三张锦囊牌',
    		yuelu:'月露',
    		yuelu_info:'在一名角色的濒死阶段，你可以弃置一张黑色牌令其回复一点体力并获得一点护甲',
    		yuelu_info_alter:'在一名角色的濒死阶段，你可以弃置一张黑色牌令其回复一点体力',
    		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:'令一名角色获得一点护甲',
    		hsqingyu_zhao:'青玉之爪',
    		hsqingyu_zhao_info:'当你装备此装备时，摸一张牌',
    		hsqingyu_feibiao:'青玉飞镖',
    		hsqingyu_feibiao_info:'弃置一名角色的一张随机手牌和一张随机装备牌',
    		hsqingyu_shandian:'青玉闪电',
    		hsqingyu_shandian_info:'对一名角色造成一点雷电伤害',
    		hsqingyu_zhanfang:'青玉绽放',
    		hsqingyu_zhanfang_info:'令一名角色增加一点体力上限并摸一张牌',
    		ayuling:'玉灵',
    		ayuling_info:'每当你受到一次伤害，你可以获得一张随机青玉牌',
    		qingzun:'青樽',
    		qingzun_info:'本局对战中，每当你使用一张青玉牌，你的手牌上限+1；当你累计使用两张青玉牌后，你可以于准备阶段摸一张牌；当你累计使用六张青玉牌后，你可以于结束阶段摸一张牌',
    		qingzun_info_alter:'本局对战中，每当你使用一张青玉牌，你的手牌上限+1；当你累计使用三张青玉牌后，你可以于准备阶段摸一张牌；当你累计使用九张青玉牌后，你可以于结束阶段摸一张牌',
    		lianjin:'炼金',
    		lianjin_info:'出牌阶段限两次，你可以将一张手牌永久转化为一张由三张随机牌组成的药水',
    		shouji:'收集',
    		shouji_info:'每当你使用一张杀，你可以获得一张目标随机手牌的复制；每当你的杀被闪避，你可以获得一张目标随机非特殊装备牌的复制；每回合限各限一次',
    		guimou:'鬼谋',
    		guimou_info:'每当你受到一次伤害，你可以获得伤害来源的一张手牌，若此牌是黑色，你展示此牌并重复此过程',
    		yingxi:'影袭',
    		yingxi_info:'结束阶段，若你本回合未造成伤害，你可以将一张黑色牌当作杀对任意一名角色使用，若目标未受到伤害，此杀不可闪避',
    		peiyu:'培育',
    		peiyu_info:'准备阶段，你可以令一名没有图腾的角色获得一个随机图腾直到其首次受到伤害',
    		peiyu_old_info:'出牌阶段，你可以弃置一张牌令一名没有图腾的角色获得一个随机图腾，或令一名有图腾的角色替换一个图腾；你死亡时，其他角色失去以此法获得的图腾',
    		wzhanyi:'战意',
    		wzhanyi_info:'你可以跳过出牌阶段，改为摸三张牌并展示之，将摸到的装备牌置于装备区，然后可以使用手牌中的杀',
    		shengteng:'升腾',
    		shengteng_info:'锁定技，每当你使用锦囊牌造成伤害，你增加一点体力上限并回复一点体力',
    		yuansu:'元素',
    		yuansu_info:'出牌阶段限一次，若你已损失的体力值不少于3，你可以将体力上限降至与体力值相同，视为使用一张元素毁灭',
    		nuyan:'怒焰',
    		nuyan2:'怒焰',
    		nuyan_backup:'怒焰',
    		nuyan_info:'出牌阶段限一次，你可以将一张红色牌当作任意一张能造成伤害的牌使用（不得是你本局以此法使用过的牌）',
    		nuyan2_info:'出牌阶段限三次，你可以失去一点体力，视为使用任意一张能造成伤害的牌”',
    		chouhuo:'仇火',
    		chouhuo_info:'觉醒技，出牌阶段开始时，若你的怒焰技能已将可用的牌用完，你失去一点体力上限，获得两点护甲，然后将怒焰的描述改为“出牌阶段限三次，你可以失去一点体力，视为使用任意一张能造成伤害的牌”',
    		hsdusu:'毒素',
    		hsdusu_xueji:'血蓟',
    		hsdusu_xueji_info:'随机弃置一名角色的2张装备牌',
    		hsdusu_shinancao:'石楠草',
    		hsdusu_shinancao_info:'令一名角色下一次造成的伤害+1',
    		hsdusu_kuyecao:'枯叶草',
    		hsdusu_kuyecao_info:'令一名角色获得技能潜行，直到其下一回合开始',
    		hsdusu_huoyanhua:'火焰花',
    		hsdusu_huoyanhua_info:'对攻击范围内的一名角色造成一点火焰伤害',
    		hsdusu_huangxuecao:'皇血草',
    		hsdusu_huangxuecao_info:'摸两张牌',
    		duxin:'毒心',
    		duxin_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:'每当你使用杀造成伤害，你可以令受伤害角色与你各流失一点体力，然后你摸两张牌',
    		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次',
    		yufa:'驭法',
    		yufa_info:'在任意一名其他角色的结束阶段，若你于此回合内受过其伤害，你可以将一张传送门交给除此角色外的任意一名角色',
    		bingyan:'冰焰',
    		bingyan_info:'出牌阶段限一次，你可以将一张红色牌当作炽羽袭，或将一张黑色牌当作惊雷闪使用',
    		hsshenqi:'神器',
    		hsshenqi_morijingxiang:'末日镜像',
    		hsshenqi_morijingxiang_info:'限武将牌正面朝上时使用，从所有其他角色的区域内各获得1~2张牌；使用后将武将牌翻至背面',
    		hsshenqi_kongbusangzhong:'恐怖丧钟',
    		hsshenqi_kongbusangzhong_info:'限武将牌正面朝上时使用，对所有其他角色各造成1~2点伤害；使用后将武将牌翻至背面',
    		hsshenqi_nengliangzhiguang:'能量之光',
    		hsshenqi_nengliangzhiguang_info:'限武将牌正面朝上时使用，令一名角色增加一点体力上限，回复一点体力，并摸四张牌；使用后将武将牌翻至背面',
    		hsbaowu:'宝物',
    		hsbaowu_huangjinyuanhou:'黄金猿猴',
    		hsbaowu_huangjinyuanhou_info:'将你的手牌（含此张）替换为随机炉石衍生牌，并获得潜行直到下一回合开始',
    		hsbaowu_cangbaotu:'藏宝图',
    		hsbaowu_cangbaotu_info:'结束阶段，将一张黄金猿猴置入你的手牌；摸一张牌',
    		hsyaoshui:'药水',
    		hsqingyu:'青玉',

    		lianzhan:'连斩',
    		lianzhan_info:'每当你造成一次伤害，若此伤害是你本回合第一次造成伤害，你摸两张牌；否则你增加一点体力上限并 回复一点体力',
    		shifa:'魔瘾',
    		shifa_info:'锁定技，每当你使用一张非转化的普通锦囊牌，你摸一张牌；出牌阶段开始时，你令你与一名随机敌人各获得一张随机普通锦囊牌',
    		yuanzheng:'远征',
    		yuanzheng_info:'每当你对距离1以外的角色使用一张牌，你可以弃置目标区域内的一张牌',
    		bzhuiji:'追击',
    		bzhuiji_info:'每当一名角色死亡，你可以摸两张牌，并视为对杀死该角色的人使用一张决斗',
    		byuhuo:'浴火',
    		byuhuo2:'浴火',
    		byuhuo_info:'觉醒技，当你进入濒死状态时，你须将体力和体力上限变为2，并将武将牌翻至背面；在你的下一准备阶段，你对所有其他角色造成两点火焰伤害，在此之前，你不能成为其他角色的卡牌的目标',
    		yulu:'雨露',
    		yulu_info:'出牌阶段限一次，你可以指定任意名角色各摸一张牌，然后各弃置一区域内的一张牌',
    		duzhang:'毒瘴',
    		duzhang2:'毒瘴',
    		duzhang_info:'结束阶段，若你于本回合内未使用过锦囊牌，你可以指定一名其他角色令其下个回合无法使用锦囊牌',
    		hannu:'寒怒',
    		hannu_info:'锁定技，每当你受到一次伤害，你将手牌数翻倍；若你的手牌数因此超过10张，你随机弃置若干张手牌直到手牌数等于你当前的体力值',
    		chuidiao:'垂钓',
    		chuidiao_info:'锁定技，结束阶段，你随机摸0~2张牌',
    		fushi:'缚誓',
    		fushi_info:'出牌阶段，你可以令一名已受伤角色失去一点体力上限并回复一点体力',
    		hhudun:'护盾',
    		hhudun_info:'锁定技，在每名角色的准备阶段，若你没有护甲，你获得一点护甲；每当你的护甲抵消一次伤害，你摸一张牌',
    		fenlie:'分裂',
    		fenlie_info:'锁定技，每当你于摸牌阶段外获得非特殊卡牌，你获得一张此牌的复制，每回合最多发动两次',
    		nianfu:'粘附',
    		nianfu_info:'锁定技，每当你造成或受到伤害，你随机获得对方装备区内的一张牌',
    		xiaorong:'消融',
    		xiaorong_info:'锁定技，你的装备牌不占用手牌上限；结束阶段，你将手牌中的每张装备牌转化为两张随机基本牌，每转化一张装备牌便回复一点体力',
    		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:'锁定技，每当你受到一次伤害，你与伤害来源各随机弃置一张牌',
    		mianyi:'免疫',
    		mianyi_info:'锁定技，你不能成为其他角色的普通锦囊牌的目标',
    		jiaohui:'教诲',
    		jiaohui_info:'结束阶段，若你没有于本回合内造成伤害，你可以令一名角色摸一张牌或回复一点体力',
    		chenshui:'沉睡',
    		chenshui_info:'结束阶段，你可以将一张随机梦境牌加入你的手牌',
    		hsmengjing:'梦境',
    		hsmengjing_card_config:'梦境',
    		hsmengjing_feicuiyoulong:'翡翠幼龙',
    		hsmengjing_feicuiyoulong_info:'出牌阶段对任意一名角色使用，对目标造成一点伤害',
    		hsmengjing_huanxiaojiemei:'欢笑姐妹',
    		hsmengjing_huanxiaojiemei_info:'出牌阶段对一名已受伤角色使用，令目标恢复一点体力',
    		hsmengjing_suxing:'苏醒',
    		hsmengjing_suxing_info:'令所有其他角色流失一点体力并随机弃置两张牌',
    		hsmengjing_mengye:'梦魇',
    		hsmengjing_mengye_info:'令一名角色摸1张牌，并在其下一个结束阶段弃置其所有牌',
    		hsmengjing_mengjing:'梦境',
    		hsmengjing_mengjing_info:'令一名角色将装备区内的所有牌收入手牌，并将一张乐不思蜀置于其判定区',
    		xjumo:'聚魔',
    		xjumo_info:'锁定技，你的手牌上限+3；若你已受伤，改为+5',
    		liehun:'裂魂',
    		liehun_info:'锁定技，结束阶段，你获得手牌中所有非基本、非特殊牌的复制',
    		malymowang:'魔网',
    		malymowang2:'魔网',
    		malymowang_info:'锁定技，你的锦囊牌在每回合中造成的首次伤害+1；出牌阶段开始时，你从3张随机锦囊中选择一张加入手牌',
    		malymowang_info_alter:'锁定技，你的锦囊牌在每回合中造成的首次伤害+1；出牌阶段开始时，随机获得一张普通锦牌牌',
    		lingzhou:'灵咒',
    		lingzhou_info:'每当你使用一张非转化的锦囊牌，可令一名角色摸一张牌或回复一点体力',
    		mieshi:'灭世',
    		mieshi_info:'锁定技，结束阶段，你流失一点体力，并对一名随机的其他角色造成一点火焰伤害',
    		xshixin:'蚀心',
    		xshixin_info:'锁定技，每当你对一名其他角色造成一次伤害，受伤害角色与你各流失一点体力',
    		xshixin_info_alter:'锁定技，每当你对一名其他角色造成一次伤害，若受伤害角色体力值不小于你，其与你各流失一点体力',
    		xmojian:'魔箭',
    		xmojian_info:'每当你的武将牌翻至正面时，你可以指定一名角色视为对其使用了一张杀',
    		enze:'恩泽',
    		enze_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:'出牌阶段限两次，你可将手牌补至四张，并于此阶段结束时弃置等量的牌',
    		hanshuang:'寒霜',
    		hanshuang_info:'锁定技，你使用黑色牌对一名未翻面角色造成伤害后，你令受伤害角色翻面，然后你流失一点体力',
    		hanshuang_info_alter:'锁定技，你使用黑色牌对一名未翻面角色造成伤害后，你令受伤害角色翻面并摸一张牌，然后你流失一点体力',
    		bingshi:'冰噬',
    		bingshi_info:'锁定技，你死亡时，对所有其他角色造成一点伤害',
    		huanwu:'唤雾',
    		huanwu_info:'出牌阶段限一次，你可以令一名角色增加一点体力上限，回复一点体力，并摸两张牌（每名角色限发动一次）',
    		fengnu:'风怒',
    		fengnu_info:'锁定技，你使用的任何卡牌无数量及距离限制；当你于回合内重复使用同名卡牌时，你摸一张牌（每回合最多以此法摸3张牌）',
    		fengnu_info_alter:'锁定技，你使用的任何卡牌无数量限制；当你于回合内重复使用同名卡牌时，你摸一张牌（每回合最多以此法摸3张牌）',
    		shengdun:'圣盾',
    		shengdun2:'圣盾',
    		shengdun_info:'锁定技，准备阶段，若你没有护甲，你获得一点护甲',
    		jingmeng:'镜梦',
    		jingmeng_info:'每当你于回合内使用第一张牌时，你可以从牌堆中随机获得一张与之类型相同的牌',
    		kuixin:'窥心',
    		kuixin_info:'结束阶段，你可以获得一名手牌数不少于你的角色的一张手牌',
    		hswuji:'无羁',
    		hswuji_info:'出牌阶段结束时，你可以摸X张牌，X为你本回合使用的卡牌数',
    		yanshu:'炎舞',
    		yanshu_info:'每回合限一次，当你弃置非基本牌后，你可以获得一张流星火雨',
    		bingshuang:'冰枪',
    		bingshuang_info:'你使用锦囊牌造成伤害后，可令目标摸两张牌并翻面',
    		shengyan:'圣言',
    		shengyan_info:'任意一名角色回复体力后，你可以令其额外回复一点体力，每回合限发动一次',
    		qingliu:'清流',
    		qingliu_info:'锁定技，你防止即将受到的火焰伤害',
    		liechao:'猎潮',
    		liechao_info:'出牌阶阶段限一次，若你的武将牌正面朝上且手牌数不大于当前体力值，你可以翻面并摸四张牌，若如此做，你跳过本回合的弃牌阶段',
    		liechao_info_alter:'出牌阶阶段限一次，若你的武将牌正面朝上且手牌数不大于当前体力值，你可以翻面并摸三张牌，若如此做，你跳过本回合的弃牌阶段',
    		aoshu:'奥术',
    		aoshu_info:'出牌阶段限一次，你可以将一张黑桃牌当作无中生有使用',

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