noname/character/swd.js

'use strict';
character.swd={
	character:{
			swd_huzhongxian:['male','wu',3,['daofa','xielv','xiangu']],

			swd_anka:['male','qun',3,['songci','anlianying']],
			swd_septem:['male','qun',4,['jiying','liaoyuan','yishan']],
			swd_kama:['female','qun',3,['yueren','shangshi']],
		// swd_miles:['male','qun',4,['aojian','miles_xueyi','mohua2']],
			swd_nicole:['female','qun',3,['huanjian','lingwu','minjing']],
			swd_wangsiyue:['female','wei',3,['duishi','biyue']],
			swd_weida:['female','qun',3,['yueren','zhenlie','duijue']],
			swd_xuanyuanjianxian:['male','qun',4,['pozhou','huajian']],

			swd_chenjingchou:['male','wu',3,['youyin','yihua']],
			swd_duguningke:['female','qun',3,['nlianji','touxi']],
			swd_guyue:['male','wei',3,['gtiandao','qinyin','wangchen']],
			swd_tuobayuer:['female','shu',4,['liuhong','poyue','niepan']],
			swd_yuwentuo:['male','shu',4,['wushuang','xielei','kunlunjing']],
			swd_yuxiaoxue:['female','wei',3,['huanhun','daixing','yinyue']],

			swd_jiliang:['male','wu',3,['yunchou','gongxin','jqimou']],
			swd_shuijing:['female','qun',4,['mojian','duanyue']],
			swd_quxian:['female','qun',3,['mojian','huanxia']],
			swd_xiyan:['male','qun',3,['zaowu','daofa']],
			swd_cheyun:['female','wu',3,['shengong','xianjiang','qiaoxie']],
			swd_huanyuanzhi:['male','qun',3,['tianshu','lanzhi','hjifeng']],
			swd_murongshi:['female','shu',4,['duanyi','guxing']],
			swd_jipeng:['male','wu',3,['reyingzi','guozao']],
			swd_qi:['male','qun',3,['yaotong','heihuo','pojian']],

			swd_luchengxuan:['male','wu',4,['ljifeng','lxianglong']],
			swd_xiarou:['female','shu',3,['xianghui','huiqi']],
			swd_moye:['female','wu',3,['rexue','liuli','senluo']],

			swd_zhaoyun:['male','shu',4,['longdan','pozhen','tanlin']],
			swd_hengai:['female','shu',3,['funiao','ningxian','hlingbo']],
			swd_duanmeng:['female','shu',4,['xuanying','lieren']],
			swd_jiangwu:['male','shu',4,['yijue','dangping']],
			swd_tuwei:['male','shu',3,['zhanlu','susheng']],
			swd_yeyaxi:['female','shu',3,['rexue','huopu','shenyan']],

			swd_muyun:['male','wei',4,['zhuhai','polang','jikong']],
			swd_lanyin:['female','wei',3,['xingdian','yulin','luomei']],
			swd_zhiyin:['female','wei',3,['xuehuang','ningshuang','zhuyu']],
			swd_qiner:['female','wei',3,['huanyin','tianhuo','xuanzhou']],
			swd_jiuyou:['male','wei',3,['lexue']],
			swd_duopeng:['male','wu',3,['luanji','reyingzi']],

			swd_fengtianling:['male','shu',4,['guiyan','jiang']],
			swd_huyue:['female','wu',3,['hyunshen','fengming']],
			swd_jialanduo:['male','qun',4,['xianyin','mailun']],
			swd_rongshuang:['female','wu',3,['suiyan','duanxing']],
			swd_zhuoshanzhu:['male','wu',4,['suiyan','wanjun']],
			swd_jiting:['female','wei',4,['guanhu','chuanyang']],

			swd_sikongyu:['male','wu',4,['sliufeng','linyun','hutian']],
			swd_muyue:['female','wei',3,['xingzhui','lingxian','shouyin']],
			swd_ziqiao:['female','shu',3,['guaili','fuyan']],
			swd_fengyu:['male','shu',4,['fzhenwei','shangxi']],

		// swd_wushi:['male','wei',3,['zhoufu','yingbin','xuying']],
			// swd_lanmoshen:['female','wei',3,['bingjian','lieren']],
			swd_huanglei:['male','qun',3,['jilve','gongshen']],
		// swd_libai:['female','qun',3,['miaobi','zhexian']],
		// swd_kendi:['male','qun',3,['guanxing','jianyan']],
		// swd_lijing:['male','qun',4,['tianyi','zhuhai']],
		swd_lilian:['female','qun',3,['swd_wuxie','qingcheng']],
		// swd_linming:['male','qun',3,['shelie','bifa']],
		// swd_philis:['male','qun',4,['yicong','wangxi']],
		// swd_pepin:['male','qun',4,['rejianxiong','quhu']],
			swd_kangnalishi:['male','qun',1,['busi','xuying','yinguo']],
			swd_xuanyuanjiantong:['male','qun',3,['chengjian','huanling']],
		swd_huiyan:['male','qun',4,['wendao','lingfeng','hxunzhi']],

		// swd_chenfu:['male','qun',4,['xuanzhou','bingfeng']],
		// swd_chengyaojin:['male','qun',4,['jiuchi','jufu']],
			swd_shanxiaoxiao:['female','wu',3,['shehun','xiaomoyu']],
			swd_yuchiyanhong:['female','shu',3,['huanxing','meihuo']],
		// swd_hanteng:['male','qun',4,['kuangfu']],
		// swd_heran:['male','qun',3,['yujian','guiyin','shejie']],
		// swd_xingtian:['male','qun',8,[]],
		// swd_qinshubao:['male','qun',3,['huajing','pingxu']],
		// swd_tuobayueer:['female','shu',3,['shushen','biyue']],
		// swd_yangshuo:['male','qun',4,['longdan','luomu']],
		// swd_zhanglie:['male','qun',4,['huajin','poxiao']],


			swd_hanluo:['male','qun',5,['hzhenwei']],
			swd_fu:['male','qun',5,['yudun']],
			swd_linyue:['male','wei',3,['zhenjiu','lmazui']],
			swd_zidashu:['male','wu',3,['shoulie','hudun']],
			swd_maixing:['male','wu',3,['toudan','shending']],
			swd_fuyan:['male','qun',4,['lianda']],
			swd_haidapang:['female','wu',3,['bingjian','rumeng']],
			swd_shaowei:['female','shu',3,['jianji','huangyu']],

			swd_youzhao:['male','shu',4,['longdan','yuchen']],
		// swd_qingming:['male','shu',3,['mingfu','tianlun']],
			swd_shangzhang:['male','shu',4,['lianwu']],
			swd_situqiang:['female','shu',3,['fengze','lingyue','jinlin']],

			swd_chunyuheng:['male','wei',2,['jueqing','shengshou','xuying']],
			swd_hanlong:['male','wei',4,['ciqiu','siji']],
			swd_yuli:['female','wu',3,['lingxin','tianxiang']],
			swd_zhanggao:['male','wei',4,['yicong','poxing']],

			swd_hupo:['male','wu',3,['dunxing','guiying']],
			swd_jiangziya:['male','wu',3,['mingfu','tianlun']],
	},
	perfectPair:{
		swd_fengtianling:['swd_huyue','swd_jiting'],
		swd_rongshuang:['swd_zhuoshanzhu'],
		swd_jialanduo:['swd_zhuoshanzhu'],
		swd_sikongyu:['swd_muyue'],
		swd_fengyu:['swd_ziqiao'],
		swd_zhaoyun:['swd_hengai','swd_yeyaxi','zhaoyun'],
		swd_hengai:['zhugeliang','sp_zhugeliang'],
		swd_duanmeng:['swd_shangzhang'],
		swd_shangzhang:['swd_situqiang'],
		swd_tuwei:['swd_hengai'],
		swd_jiangwu:['swd_zhaoyun'],
		swd_muyun:['swd_lanyin','swd_zhiyin','swd_zhanggao','xushu'],
		swd_lanyin:['swd_zhiyin'],
		swd_yuli:['swd_chunyuheng'],
		swd_jiuyou:['swd_zhiyin'],
		swd_qiner:['swd_hengai'],
		swd_huzhongxian:['swd_jiliang','swd_jipeng','swd_xiyan'],
		swd_anka:['swd_kama'],
		swd_septem:['swd_nicole','swd_kama','swd_weida','swd_wangsiyue','swd_huiyan'],
		swd_nicole:['swd_lilian'],
		swd_xuanyuanjianxian:['swd_xuanyuanjiantong'],
		swd_chenjingchou:['swd_yuxiaoxue','swd_tuobayuer'],
		swd_yuxiaoxue:['swd_yuwentuo'],
		swd_zhanglie:['swd_tuobayuer'],
		swd_duguningke:['swd_yuwentuo','swd_shanxiaoxiao','swd_yuchiyanhong'],
		swd_jiliang:['swd_shuijing','swd_jipeng'],
		swd_jipeng:['swd_duopeng'],
		swd_cheyun:['swd_huanyuanzhi','swd_murongshi'],
		swd_murongshi:['swd_huanyuanzhi','swd_shuijing'],
		swd_huanyuanzhi:['swd_jipeng'],
		swd_qi:['swd_huzhongxian'],
		swd_luchengxuan:['swd_xiarou'],
	},
	skill:{
		shenyan:{
			trigger:{source:'damageBegin'},
			skillAnimation:true,
			animationColor:'fire',
			filter:function(event,player){
				return !player.storage.shenyan&&event.nature=='fire';
			},
			intro:{
				content:'limited'
			},
			mark:true,
			logTarget:'player',
			init:function(player){
				player.storage.shenyan=false;
			},
			check:function(event,player){
				if(ai.get.attitude(player,event.player)>=0) return 0;
				if(player.hasUnknown()) return 0;
				var num=0;
				for(var i=0;i<game.players.length;i++){
					if(game.players[i]!=player&&
						game.players[i]!=event.player&&
						get.distance(event.player,game.players[i])<=1){
						var eff=ai.get.damageEffect(game.players[i],player,player,'fire');
						if(eff>0){
							num++;
						}
						else if(eff<0){
							num--;
						}
					}
				}
				return num>0;
			},
			content:function(){
				trigger.num++;
				player.addSkill('shenyan2');
				player.storage.shenyan=true;
				player.awakenSkill('shenyan');
				player.storage.shenyan2=[];
				for(var i=0;i<game.players.length;i++){
					if(game.players[i]!=player&&
						game.players[i]!=trigger.player&&
						get.distance(trigger.player,game.players[i])<=1){
						player.storage.shenyan2.push(game.players[i]);
					}
				}
				player.storage.shenyan2.sort(lib.sort.seat);
			}
		},
		shenyan2:{
			trigger:{global:'damageAfter'},
			forced:true,
			popup:false,
			content:function(){
				'step 0'
				if(player.storage.shenyan2&&player.storage.shenyan2.length){
					var target=player.storage.shenyan2.shift();
					player.line(target,'fire');
					target.damage('fire');
					event.redo();
				}
				'step 1'
				delete player.storage.shenyan2;
				player.removeSkill('shenyan2');
			}
		},
		senluo:{
			enable:'phaseUse',
			usable:1,
			filter:function(event,player){
				var nh=player.num('h');
				for(var i=0;i<game.players.length;i++){
					if(game.players[i]!=player&&game.players[i].num('h')<nh) return false;
				}
				return true;
			},
			filterTarget:function(card,player,target){
				return target!=player&&target.num('h')>0;
			},
			content:function(){
				'step 0'
				target.draw();
				'step 1'
				target.chooseToDiscard(2,'h',true);
			},
			selectTarget:-1,
			ai:{
				order:9,
				result:{
					target:-1
				}
			}
		},
		xuanying:{
			subSkill:{
				sha:{
					enable:'chooseToUse',
					viewAs:{name:'sha'},
					viewAsFilter:function(player){
						if(player.isLinked()) return false;
					},
					precontent:function(){
						player.link();
						// player.getStat().card.sha--;
					},
					filterCard:function(){return false},
					selectCard:-1,
					prompt:'横置武将牌，视为使用一张无视距离的杀',
					ai:{
						order:function(){
							// if(_status.event.player.num('h',{type:'equip'})) return 9;
							return 3.15;
						},
						skillTagFilter:function(player,tag,arg){
							if(arg!='use') return false;
							if(player.isLinked()) return false;
						},
						respondSha:true,
					},
					mod:{
						targetInRange:function(card){
							if(_status.event.skill=='xuanying_sha') return true;
						}
					},
				},
				shan:{
					trigger:{player:'chooseToRespondBegin'},
					filter:function(event,player){
						if(!player.isLinked()) return false;
						if(event.responded) return false;
						if(!event.filterCard({name:'shan'})) return false;
						return true;
					},
					check:function(event,player){
						if(ai.get.damageEffect(player,event.player,player)>=0) return false;
						return true;
					},
					content:function(){
						'step 0'
						player.link();
						'step 1'
						trigger.untrigger();
						trigger.responded=true;
						trigger.result={bool:true,card:{name:'shan'}}
					},
					ai:{
						effect:{
							target:function(card,player,target,effect){
								if(get.tag(card,'respondShan')) return 0.1;
							}
						}
					}
				},
				damage:{
					trigger:{player:'damageEnd'},
					filter:function(event,player){
						return event.source&&event.source.isAlive()&&player.isLinked()&&
						lib.filter.targetEnabled({name:'sha'},player,event.source);
					},
					check:function(event,player){
						return ai.get.effect(event.source,{name:'sha'},player,player)>0;
					},
					logTarget:'source',
					content:function(){
						'step 0'
						player.link();
						'step 1'
						player.useCard({name:'sha'},trigger.source);
					}
				},
				use:{
					trigger:{player:'loseEnd'},
					direct:true,
					filter:function(event,player){
						return _status.currentPhase!=player&&player.isLinked()&&event.cards&&event.cards.length;
					},
					content:function(){
						'step 0'
						player.chooseTarget(get.prompt('xuanying'),function(card,player,target){
							return lib.filter.targetEnabled({name:'sha'},player,target);
						}).set('ai',function(target){
							return ai.get.effect(target,{name:'sha'},_status.event.player);
						});
						'step 1'
						if(result.bool){
							player.logSkill('xuanying');
							if(!event.isMine()) game.delay(0.5);
							player.link();
							player.useCard({name:'sha'},result.targets,false);
						}
					},
				}
			},
			group:['xuanying_sha','xuanying_use'],
			ai:{
				threaten:function(player,target){
					if(target.isLinked()) return 0.7;
					return 1.4;
				}
			}
		},
		wendao:{
			trigger:{player:['useCardAfter','respondAfter',]},
			check:function(event,player){
				return ai.get.attitude(player,_status.currentPhase)<=0;
			},
			logTarget:function(){
				return _status.currentPhase;
			},
			filter:function(event,player){
				if(player==_status.currentPhase) return false;
				if(!_status.currentPhase.num('he')) return false;
				return event.cards&&event.cards.length==1;
			},
			content:function(){
				'step 0'
				var suit=get.suit(trigger.cards[0]);
				var goon=(ai.get.attitude(_status.currentPhase,player)<=0);
				_status.currentPhase.chooseToDiscard('弃置一张'+get.translation(suit+'2')+
				'牌，或令'+get.translation(player)+'获得你的一张牌',{suit:suit}).ai=function(card){
					if(goon) return 8-ai.get.value(card);
					return 0;
				}
				'step 1'
				if(!result.bool){
					player.gainPlayerCard(_status.currentPhase,'he',true);
				}
			},
			ai:{
				threaten:0.7
			}
		},
		lingfeng:{
			trigger:{player:'phaseEnd'},
			frequent:true,
			filter:function(event,player){
				return get.cardCount(true,player)>=Math.min(3,player.hp);
			},
			content:function(){
				'step 0'
				player.chooseTarget('凌锋：造成一点伤害，或取消并获得一点护甲',function(card,player,target){
					return player!=target&&get.distance(player,target,'attack')<=1;
				}).ai=function(target){
					if(player.hp==1) return 0;
					if(player.hp==2&&target.hp>=3) return 0;
					return ai.get.damageEffect(target,player,player);
				}
				'step 1'
				if(result.bool){
					player.line(result.targets[0]);
					result.targets[0].damage();
				}
				else{
					player.changeHujia();
				}
			},
			ai:{
				order:-10,
				result:{
					target:2
				},
				threaten:1.5
			}
		},
		hxunzhi:{
			unique:true,
			enable:'phaseUse',
			filter:function(event,player){
				return !player.storage.hxunzhi;
			},
			init:function(player){
				player.storage.hxunzhi=false;
			},
			mark:true,
			intro:{
				content:'limited'
			},
			skillAnimation:true,
			animationColor:'fire',
			content:function(){
				'step 0'
				player.awakenSkill('hxunzhi');
				player.storage.hxunzhi=true;
				var targets=[];
				for(var i=0;i<game.players.length;i++){
					if(player.canUse({name:'wanjian'},game.players[i])){
						targets.push(game.players[i]);
					}
				}
				targets.sort(lib.sort.seat);
                player.useCard({name:'wanjian'},targets);
				'step 1'
				player.addSkill('wusheng');
				player.addSkill('paoxiao');
				player.addSkill('hxunzhi2');
			},
			ai:{
				order:2,
				result:{
					player:function(player){
						if(get.mode()=='identity'){
							if(player.identity=='zhu') return 0;
							if(player.identity=='nei') return 0;
						}
						else if(get.mode()=='guozhan'){
							if(player.identity=='ye') return 0;
							if(player.isUnseen()) return 0;
						}
						if(player.hp==1) return 1;
						if(player.hasUnknown()) return 0;
						if(!player.hasFriend()) return 0;
						var enemies=player.getEnemies();
						if(enemies.length+1==game.players.length) return 0;
						var num=player.num('h',function(card){
							return card.name=='sha'||get.color(card)=='red';
						});
						if(num<2) return 0;
						for(var i=0;i<enemies.length;i++){
							if(player.canUse('sha',enemies[i])&&
							ai.get.effect(enemies[i],{name:'sha'},player,player)>0&&
							!enemies[i].get('e','2')&&num>enemies[i].hp&&enemies[i].hp<=2){
								return 1;
							}
						}
						return 0;
					}
				}
			}
		},
		hxunzhi2:{
			trigger:{player:'phaseUseEnd'},
			forced:true,
			popup:false,
			content:function(){
				player.removeSkill('xunzhi2');
				player.die();
			}
		},
		hjifeng:{
			trigger:{player:'phaseEnd'},
			filter:function(event,player){
				if(!player.num('e')) return false;
				if(player.num('h',{type:'jiqi'})) return false;
				if(get.cardPile(function(card){return get.type(card)=='jiqi'})) return true;
				return false;
			},
			direct:true,
			content:function(){
				'step 0'
				player.chooseToDiscard('e','祭风：是否弃置一张装备牌并获得一张祭器牌？').set('ai',function(card){
					return 6-ai.get.value(card);
				}).logSkill='hjifeng';
				'step 1'
				if(result.bool){
					var card=get.cardPile(function(card){
						return get.type(card)=='jiqi'&&card.name.indexOf('yuchan')!=0;
					})||get.cardPile(function(card){
						return get.type(card)=='jiqi';
					});
					if(card){
						player.gain(card,'draw');
					}
				}
			}
		},
		lmazui:{
			audio:'mazui',
			enable:'phaseUse',
			usable:1,
			filterCard:{color:'black'},
			filterTarget:function(card,player,target){
				return !target.hasSkill('lmazui2');
			},
			check:function(card){
				return 6-ai.get.value(card);
			},
			discard:false,
			prepare:'give',
			content:function(){
				target.storage.lmazui2=cards[0];
				target.addSkill('lmazui2');
				game.addVideo('storage',target,['lmazui2',get.cardInfo(target.storage.lmazui2),'card']);
			},
			ai:{
				expose:0.2,
				result:{
					target:function(player,target){
						return -target.hp;
					}
				},
				order:4,
				threaten:1.2
			}
		},
		lmazui2:{
			trigger:{source:'damageBegin'},
			forced:true,
			mark:'card',
			filter:function(event){
				return event.num>0;
			},
			content:function(){
				trigger.num--;
				player.addSkill('lmazui3');
				player.removeSkill('lmazui2');
			},
			intro:{
				content:'card'
			}
		},
		lmazui3:{
			trigger:{source:'damageEnd'},
			forced:true,
			popup:false,
			content:function(){
				player.gain(player.storage.lmazui2,'gain2','log');
				player.removeSkill('lmazui3');
				delete player.storage.lmazui2;
			}
		},
		hyunshen:{
			trigger:{player:'respond'},
			filter:function(event,player){
				return event.card.name=='shan';
			},
			frequent:true,
			init:function(player){
				player.storage.hyunshen=0;
			},
			content:function(){
				player.storage.hyunshen++;
				player.markSkill('hyunshen');
			},
			ai:{
				effect:{
					target:function(card,player,target){
						if(get.tag(card,'respondShan')){
							var shans=target.num('h','shan');
							var hs=target.num('h');
							if(shans>1) return [1,1];
							if(shans&&hs>2) return [1,1];
							if(shans) return [1,0.5];
							if(hs>2) return [1,0.3];
							if(hs>1) return [1,0.2];
							return [1.2,0];
						}
					}
				},
				threaten:0.8
			},
			intro:{
				content:'mark'
			},
			group:'hyunshen2'
		},
		hyunshen2:{
			trigger:{player:'phaseBegin'},
			forced:true,
			filter:function(event,player){
				return player.storage.hyunshen>0;
			},
			content:function(){
				player.draw(player.storage.hyunshen);
				player.storage.hyunshen=0;
				player.unmarkSkill('hyunshen');
			},
			mod:{
				globalTo:function(from,to,distance){
					if(typeof to.storage.hyunshen=='number') return distance+to.storage.hyunshen;
				}
			}
		},
		hlingbo:{
			audio:['lingbo',2],
			trigger:{player:'respond'},
			filter:function(event,player){
				return event.card.name=='shan';
			},
			frequent:true,
			content:function(){
				player.draw(2);
			},
			ai:{
				mingzhi:false,
				effect:{
					target:function(card,player,target){
						if(get.tag(card,'respondShan')){
							var shans=target.num('h','shan');
							var hs=target.num('h');
							if(shans>1) return [0,1];
							if(shans&&hs>2) return [0,1];
							if(shans) return [0,0];
							if(hs>2) return [0,0];
							if(hs>1) return [1,0.5];
							return [1.5,0];
						}
					}
				},
				threaten:0.8
			}
		},
		gtiandao:{
			audio:true,
			trigger:{global:'judge'},
			direct:true,
			filter:function(event,player){
				return player.num('he')>0;
			},
			content:function(){
				"step 0"
				player.chooseCard(get.translation(trigger.player)+'的'+(trigger.judgestr||'')+'判定为'+
				get.translation(trigger.player.judging[0])+'，'+get.prompt('gtiandao'),'he').ai=function(card){
					var trigger=_status.event.parent._trigger;
					var player=_status.event.player;
					var result=trigger.judge(card)-trigger.judge(trigger.player.judging[0]);
					var attitude=ai.get.attitude(player,trigger.player);
					if(attitude==0||result==0) return 0;
					if(attitude>0){
						return result;
					}
					else{
						return -result;
					}
				};
				"step 1"
				if(result.bool){
					player.respond(result.cards,'highlight');
				}
				else{
					event.finish();
				}
				"step 2"
				if(result.bool){
					player.logSkill('gtiandao');
					player.$gain2(trigger.player.judging[0]);
					player.gain(trigger.player.judging[0]);
					trigger.player.judging[0]=result.cards[0];
					trigger.position.appendChild(result.cards[0]);
					game.log(trigger.player,'的判定牌改为',result.cards[0]);
				}
				"step 3"
				game.delay(2);
			},
			ai:{
				tag:{
					rejudge:1
				},
				threaten:1.5
			}
		},
		jinlin:{
            enable:'phaseUse',
            unique:true,
			mark:true,
			skillAnimation:true,
			animationColor:'metal',
			init:function(player){
				player.storage.jinlin=false;
			},
			filter:function(event,player){
				if(player.storage.jinlin) return false;
                return true;
			},
            filterTarget:true,
            selectTarget:[1,Infinity],
			content:function(){
                if(target==targets[0]){
                    player.awakenSkill('jinlin');
    				player.storage.jinlin=true;
                }
				target.changeHujia(3);
				target.addSkill('jinlin2');
				target.storage.jinlin2=3;
			},
			ai:{
				order:1,
				result:{
					target:function(player,target){
                        if(player.hp==1) return 1;
						var num=0;
						for(var i=0;i<game.players.length;i++){
							if(ai.get.attitude(player,game.players[i])>2){
								if(game.players[i].hp==1) return 1;
								if(game.players[i].hp==2) num++;
							}
						}
                        if(player.hasUnknown()) return 0;
						if(num>1) return 1;
                        return 0;
                    }
				},
			},
			intro:{
				content:'limited'
			}
        },
		jinlin2:{
			trigger:{player:'phaseBegin'},
			forced:true,
			popup:false,
			content:function(){
				if(player.hujia>0){
					player.changeHujia(-1);
				}
				player.storage.jinlin2--;
				if(player.hujia==0||player.storage.jinlin2==0){
					player.removeSkill('jinlin2');
					delete player.storage.jinlin2;
				}
			},
		},
		lingyue:{
			trigger:{player:'shaBegin'},
			check:function(event,player){
				return ai.get.attitude(player,event.target)<0;
			},
			filter:function(event,player){
				return event.target.num('he')>0;
			},
			content:function(){
				trigger.target.chooseToDiscard('he',true);
			}
		},
		fengze:{
			enable:'phaseUse',
			filterCard:{color:'black'},
			selectCard:1,
			position:'he',
			usable:1,
			viewAs:{name:'taoyuan'},
			filter:function(event,player){
				return player.num('he',{color:'black'})>0;
			},
			audio:true,
			prompt:'将一张黑色牌当作桃园结义使用',
			check:function(card){
				return 7-ai.get.useful(card)
			},
			ai:{
				threaten:1.5
			}
		},
		zaowu:{
			enable:'phaseUse',
			usable:1,
			filter:function(event,player){
				return player.num('he',{suit:'spade'})>0;
			},
			position:'he',
			filterCard:{suit:'spade'},
			viewAs:{name:'fengyinzhidan'},
			check:function(card){
				return 6-ai.get.value(card);
			},
			ai:{
				order:2,
			}
		},
		huanxia:{
			enable:'chooseToUse',
			filterCard:function(card){
				return get.color(card)=='red';
			},
			position:'he',
			viewAs:{name:'sha'},
			viewAsFilter:function(player){
				if(!player.num('he',{color:'red'})) return false;
			},
			prompt:'将一张红色牌当杀使用',
			check:function(card){return 5-ai.get.value(card)},
			ai:{
				order:3.1,
				skillTagFilter:function(player){
					if(!player.num('he',{color:'red'})) return false;
				},
			},
			group:['huanxia_expire','huanxia_draw','huanxia_gain'],
			subSkill:{
				expire:{
					trigger:{source:'damageAfter'},
					forced:true,
					popup:false,
					filter:function(event){
						return event.parent.skill=='huanxia';
					},
					content:function(){
						player.storage.huanxia=true;
					}
				},
				draw:{
					trigger:{player:'shaAfter'},
					forced:true,
					popup:false,
					content:function(){
						if(trigger.parent.skill=='huanxia'){
							var card=trigger.cards[0];
							if(get.itemtype(card)=='card'&&get.position(card)=='d'&&!player.storage.huanxia){
								ui.special.appendChild(card);
								if(!player.storage.huanxia_draw){
									player.storage.huanxia_draw=[];
								}
								player.storage.huanxia_draw.push(card);
							}
						}
						delete player.storage.huanxia;
					}
				},
				gain:{
					trigger:{player:'phaseEnd'},
					forced:true,
					filter:function(event,player){
						return player.storage.huanxia_draw;
					},
					content:function(){
						player.gain(player.storage.huanxia_draw,'gain2');
						delete player.storage.huanxia_draw;
					}
				}
			}
		},
		kongmo:{
			trigger:{player:'useCardAfter'},
			forced:true,
			filter:function(event,player){
				if(event.parent.name=='kongmo') return false;
				if(!event.targets||!event.card) 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);
				for(var i=0;i<event.targets.length;i++){
					if(!event.targets[i].isAlive()) return false;
					if(!player.canUse({name:event.card.name},event.targets[i],false,false)){
						return false;
					}
				}
				return true;
			},
			content:function(){
				var card=game.createCard(trigger.card.name,trigger.card.suit,trigger.card.number);
				player.useCard(card,trigger.targets);
			},
			ai:{
				threaten:2
			}
		},
		huajing:{
			trigger:{source:'damageEnd'},
			filter:function(event,player){
				return event.card&&get.type(event.card,'trick')=='trick';
			},
			frequent:true,
			content:function(){
				player.recover();
				player.draw();
			}
		},
		pingxu:{
			mod:{
				globalFrom:function(from,to,current){
					if(!from.get('e','1')) return current-1;
				},
				globalTo:function(from,to,current){
					if(!to.get('e','2')) return current+1;
				},
			}
		},
		jufu:{
			trigger:{source:'damageBegin'},
			filter:function(event,player){
				if(event.card&&event.card.name=='sha'&&player.get('e','1')) return true;
				return false;
			},
			forced:true,
			content:function(){
				trigger.num++;
			}
		},
		bingfeng:{
			skillAnimation:'epic',
			animationColor:'water',
			unique:true,
			enable:'phaseUse',
			filter:function(event,player){
				return !player.storage.bingfeng;
			},
			init:function(player){
				player.storage.bingfeng=false;
			},
			filterTarget:function(card,player,target){
				return player!=target&&!target.isTurnedOver();
			},
			mark:true,
			multitarget:true,
			multiline:true,
			selectTarget:[1,3],
			content:function(){
				"step 0"
				player.awakenSkill('bingfeng');
				player.removeSkill('xuanzhou');
				player.loseMaxHp();
				player.storage.bingfeng=true;
				event.num=0;
				player.turnOver();
				player.addSkill('bingfeng2');
				"step 1"
				if(num<targets.length){
					var target=targets[num];
					if(!target.isTurnedOver()){
						target.turnOver();
					}
					target.addSkill('bingfeng2');
					event.num++;
					event.redo();
				}
			},
			intro:{
				content:'limited'
			},
			ai:{
				order:1,
				result:{
					target:function(player,target){
						if(game.phaseNumber<game.players.length) return 0;
						if(game.phaseNumber<game.players.length*2&&player.hp==player.maxHp) return 0;
						switch(lib.config.mode){
							case 'identity':{
								for(var i=0;i<game.players.length;i++){
									if(game.players[i].ai.shown==0) return 0;
								}
								switch(player.identity){
									case 'zhu':{
										if(ai.get.situation()>=0) return 0;
										if(get.population('fan')<3) return 0;
										return -1;
									}
									case 'zhong':{
										if(get.population('fan')<3) return 0;
										return -1;
									}
									case 'nei':return 0;
									case 'fan':{
										if(get.population('fan')==0) return 0;
										if(get.population('zhong')<2) return 0;
										return -1;
									}
								}
								break;
							}
							case 'guozhan':{
								if(player.identity=='unknown') return 0;
								return get.population(player.identity)>=3?-1:0;
							}
							default:{
								return -1;
							}
						}
					},
				}
			}
		},
		bingfeng2:{
			mod:{
				cardEnabled:function(){
					return false;
				},
				cardUsable:function(){
					return false;
				},
				cardRespondable:function(){
					return false;
				},
				cardSavable:function(){
					return false;
				}
			},
			trigger:{player:'turnOverAfter'},
			forced:true,
			filter:function(event,player){
				return !player.isTurnedOver();
			},
			content:function(){
				player.removeSkill('bingfeng2');
			}
		},
		yudun:{
			mod:{
				cardEnabled:function(card,player){
					if(get.type(card,'trick')=='trick') return false;
				},
				cardRespondable:function(card,player){
					if(get.type(card,'trick')=='trick') return false;
				},
				cardSavable:function(card,player){
					if(get.type(card,'trick')=='trick') return false;
				},
			},
			enable:'chooseToUse',
			filterCard:function(card){
				return get.type(card,'trick')=='trick';
			},
			selectCard:2,
			viewAs:{name:'sha'},
			viewAsFilter:function(player){
				if(player.num('h',{type:['trick','delay']})<2) return false;
			},
			check:function(){return 1},
			ai:{
				skillTagFilter:function(player,tag,arg){
					if(arg!='use') return false;
					if(player.num('h',{type:['trick','delay']})<2) return false;
				},
				respondSha:true,
				order:3.1,
				useful:-1,
				value:-1
			},
			group:'yudun_count',
			subSkill:{
				count:{
					trigger:{player:'useCard'},
					forced:true,
					popup:false,
					filter:function(event,player){
						return event.skill=='yudun'&&_status.currentPhase==player;
					},
					content:function(){
						player.getStat().card.sha--;
					}
				}
			}
		},
		guozao:{
			trigger:{global:'damageEnd'},
			forced:true,
			logv:false,
			check:function(event,player){
				for(var i=0;i<game.players.length;i++){
					if(ai.get.attitude(player,game.players[i])>2&&game.players[i].num('h')==1){
						return true;
					}
				}
				return false;
			},
			filter:function(event,player){
				if(event.source==player) return false;
				if(get.distance(player,event.player)>1) return false;
				for(var i=0;i<game.players.length;i++){
					if(game.players[i].num('h')) return true;
				}
				return false;
			},
			content:function(){
				"step 0"
				var cards=[];
				if(ui.cardPile.childNodes.length<3){
					var discardcards=get.cards(3);
					for(var i=0;i<discardcards.length;i++){
						ui.discardPile.appendChild(discardcards[i]);
					}
				}
				for(var i=0;i<3;i++){
					cards.push(ui.cardPile.childNodes[i]);
				}
				event.cards=cards;
				var dialog=ui.create.dialog('聒噪：选择一个目标将手牌替换',cards,'hidden');
				dialog.classList.add('noselect');
				var next=player.chooseTarget(true,dialog,function(card,player,target){
					return target.num('h')>0&&get.distance(player,target)<=2;
				}).ai=function(target){
					var att=ai.get.attitude(player,target);
					var hs=target.get('h');
					var num=hs.length;
					if(num<=1) return att*2;
					if(num==2){
						for(var i=0;i<cards.length;i++){
							if(ai.get.value(cards[i])>6,target,'raw') return att;
						}
						if(target==player){
							for(var i=0;i<2;i++){
								if(ai.get.value(cards[i])>6,target,'raw') return -1;
							}
						}
						return att/2;
					}
					if(num==3){
						if(target==player){
							var num2=0;
							for(var i=0;i<3;i++){
								num2+=ai.get.value(cards[i],player,'raw');
								num2-=ai.get.value(hs[i],player,'raw');
							}
							if(num2>0) return 0.5;
							if(num2<0) return -0.5;
						}
						return 0;
					}
					return -att/2;
				};
				"step 1"
				if(result.bool&&result.targets[0]){
					var target=result.targets[0];
					player.logSkill('guozao',target,'green',true);
					var cards=target.get('h');
					target.lose(cards)._triggered=null;
					game.log(target,'弃置了',cards,'，并获得三张牌');
					// target.$draw(3);
					target.$throw(cards);
					target.gain(event.cards,'draw')._triggered=null;
				}
				else{
					event.finish();
				}
			},
			ai:{
				expose:0.1
			}
		},
		heihuo:{
			enable:'phaseUse',
			filter:function(event,player){
				return player.num('h')>0&&player.num('he',{type:'equip'})>0&&!player.hasSkill('heihuo2');
			},
			filterCard:function(card){
				return get.type(card)=='equip';
			},
			position:'he',
			check:function(card){
				var player=_status.currentPhase;
				var nh=player.num('h');
				var pos=get.position(card);
				if(nh<2) return 0;
				if(nh>4) return 0;
				if(nh==4&&pos=='e') return 0;
				if(player.num('he',{subtype:get.subtype(card)})>1){
					return 11-ai.get.equipValue(card)+(pos=='e'?0.4:0);
				}
				return 5.5-ai.get.value(card)+(pos=='e'?0.4:0);
			},
			content:function(){
				"step 0"
				player.draw(player.num('h'));
				"step 1"
				if(player.num('h')>=8){
					player.damage(3,'fire');
					player.addTempSkill('heihuo2','phaseAfter');
				}
			},
			ai:{
				order:10,
				threaten:1.4,
				result:{
					player:1
				}
			}
		},
		heihuo2:{},
		yaotong:{
			group:['yaotong1','yaotong2','yaotong3'],
			ai:{
				respondSha:true,
				respondShan:true,
				skillTagFilter:function(player){
					if(player.num('h')%2==0) return false;
				},
			},
			threaten:1.3
		},
		yaotong1:{
			enable:['chooseToRespond','chooseToUse'],
			filterCard:true,
			viewAs:{name:'sha'},
			filter:function(event,player){
				var num=player.num('h');
				if(num==0) return false;
				return num%2==1;
			},
			prompt:'将一张手牌当作杀打出',
			check:function(card){return 6-ai.get.value(card)}
		},
		yaotong2:{
			enable:['chooseToRespond','chooseToUse'],
			filterCard:true,
			viewAs:{name:'shan'},
			filter:function(event,player){
				var num=player.num('h');
				if(num==0) return false;
				return num%2==1;
			},
			prompt:'将一张手牌当作闪打出',
			check:function(card){return 6-ai.get.value(card)}
		},
		yaotong3:{
			enable:'chooseToUse',
			filterCard:true,
			viewAs:{name:'wuxie'},
			filter:function(event,player){
				var num=player.num('h');
				if(num==0) return false;
				return num%2==0;
			},
			viewAsFilter:function(player){
				var num=player.num('h');
				if(num==0) return false;
				return num%2==0;
			},
			prompt:'将一张手牌当作无懈可击使用',
			check:function(card){return 7-ai.get.value(card)},
		},
		yaotong4:{
			enable:'chooseToUse',
			filterCard:true,
			viewAs:{name:'tao'},
			filter:function(event,player){
				var num=player.num('h');
				if(num==0) return false;
				return num%2==0;
			},
			viewAsFilter:function(player){
				var num=player.num('h');
				if(num==0) return false;
				return num%2==0;
			},
			prompt:'将一张手牌当作桃使用',
			check:function(card){return 9-ai.get.value(card)},
		},
		pojian:{
			trigger:{player:'loseEnd'},
			filter:function(event,player){
				if(player.num('h')) return false;
				for(var i=0;i<event.cards.length;i++){
					if(event.cards[i].original=='h') return true;
				}
				return false;
			},
			content:function(){
				for(var i=0;i<ui.cardPile.childNodes.length;i++){
					if(get.type(ui.cardPile.childNodes[i])=='equip'){
						player.equip(ui.cardPile.childNodes[i]);
						player.$gain2(ui.cardPile.childNodes[i]);
						game.delay();
						event.finish();
						return;
					}
				}
				for(var i=0;i<ui.discardPile.childNodes.length;i++){
					if(get.type(ui.discardPile.childNodes[i])=='equip'){
						player.equip(ui.discardPile.childNodes[i]);
						player.$gain2(ui.discardPile.childNodes[i]);
						game.delay();
						event.finish();
						return;
					}
				}
			},
		},
		huajin:{
			enable:'phaseUse',
			usable:1,
			filter:function(event,player){
				return player.num('he')>0;
			},
			filterCard:true,
			position:'he',
			content:function(){
				player.addSkill('huajin2');
			},
			check:function(card){
				return 5-ai.get.value(card);
			},
			ai:{
				order:10,
				result:{
					player:function(player){
						if(player.num('h','juedou')) return 1;
						if(player.num('h','sha')==0) return 0;
						for(var i=0;i<game.players.length;i++){
							if(player.canUse('sha',game.players[i])&&
							ai.get.effect(game.players[i],{name:'sha'},player,player)>0){
								return 1;
							}
						}
						return 0;
					}
				}
			}
		},
		huajin2:{
			trigger:{source:'damageBegin'},
			forced:true,
			content:function(){
				trigger.num++;
			},
			group:'huajin3'
		},
		huajin3:{
			trigger:{player:'phaseBegin'},
			forced:true,
			popup:false,
			content:function(){
				player.removeSkill('huajin2');
			}
		},
		yuchen:{
			trigger:{player:['useCard','respondAfter']},
			direct:true,
			filter:function(event,player){
				if(player==_status.currentPhase) 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"
				game.delay(0.5);
				player.chooseTarget(get.prompt('yuchen'),function(card,player,target){
					return player!=target&&target.num('he')>0;
				}).ai=function(target){
					return -ai.get.attitude(player,target);
				};
				"step 1"
				if(result.bool){
					player.logSkill('yuchen',result.targets);
					player.discardPlayerCard(result.targets[0],true);
				}
			},
			ai:{
				threaten:0.7
			}
		},
		bingjian:{
			enable:'phaseUse',
			usable:1,
			filter:function(event,player){
				return player.num('he',{color:'black',name:'sha'})>0;
			},
			filterCard:function(card){
				return card.name=='sha'&&get.color(card)=='black';
			},
			filterTarget:function(card,player,target){
				return player!=target&&target.num('h')>0;
			},
			line:'thunder',
			content:function(){
				"step 0"
				target.showHandcards();
				"step 1"
				var cards=target.get('h','shan');
				if(cards.length){
					target.discard(cards);
				}
				else{
					target.damage('thunder');
				}
			},
			ai:{
				order:5,
				result:{
					target:function(player,target){
						return ai.get.damageEffect(target,player,target,'thunder');
					}
				},
				expose:0.2
			}
		},
		rumeng:{
			trigger:{global:'phaseUseBefore'},
			direct:true,
			filter:function(event,player){
				return event.player!=player&&player.num('he',{type:'basic'})<player.num('he');
			},
			content:function(){
				"step 0"
				var yep=ai.get.attitude(player,trigger.player)<0&&
					trigger.player.num('h')>2;
				var next=player.chooseToDiscard(function(card){
					return get.type(card)!='basic';
				},get.prompt('rumeng',trigger.player),'he');
				next.logSkill=['rumeng',trigger.player];
				next.ai=function(card){
					if(yep){
						return 6-ai.get.value(card);
					}
					return 0;
				}
				"step 1"
				if(result.bool){
					trigger.player.chooseToDiscard({type:'basic'},'入梦：弃置一张基本牌或跳过出牌及弃牌阶段').ai=function(card){
						return 5-ai.get.value(card);
					}
				}
				else{
					event.finish();
				}
				"step 2"
				if(!result.bool){
					trigger.untrigger();
					trigger.finish();
					trigger.player.skip('phaseDiscard');
				}
			},
			ai:{
				expose:0.1
			}
		},
		lianda:{
			trigger:{player:'shaAfter'},
			direct:true,
			filter:function(event,player){
				return event.target.isAlive()&&player.num('he')>0&&!player.hasSkill('lianda2');
			},
			content:function(){
				"step 0"
				var next=player.chooseToDiscard('he',get.prompt('lianda'));
				next.ai=function(card){
					if(ai.get.effect(trigger.target,{name:'sha'},player,player)>0){
						return 7-ai.get.value(card);
					}
					return 0;
				}
				next.logSkill='lianda';
				"step 1"
				if(result.bool){
					player.addTempSkill('lianda2','phaseAfter');
					player.useCard({name:'sha'},trigger.target);
				}
			}
		},
		lianda2:{},
		huiqi:{
			trigger:{player:'damageEnd'},
			direct:true,
			filter:function(event,player){
				return player.hp<player.maxHp;
			},
			content:function(){
				"step 0"
				player.chooseTarget(get.prompt('huiqi'),function(card,player,target){
					return player!=target;
				}).ai=function(target){
					var att=ai.get.attitude(player,target);
					if(player.hp<=0){
						if(player==target){
							return 1;
						}
						if(att>3){
							return att+Math.max(0,5-target.num('h'));
						}
						return att/4;
					}
					if(att>3){
						return att+Math.max(0,5-target.num('h'));
					}
					return att;
				}
				"step 1"
				if(result.bool){
					player.logSkill('huiqi',result.targets);
					result.targets[0].draw(player.maxHp-player.hp);
				}
			},
			ai:{
				expose:0.2,
				effect:{
					target:function(card,player,target){
						if(get.tag(card,'damage')){
							return [1,0.5];
						}
					}
				}
			}
		},
		xianghui:{
			enable:'phaseUse',
			usable:1,
			filterCard:{color:'red'},
			filter:function(){
				var min=game.players[0].hp;
				for(var i=0;i<game.players.length;i++){
					min=Math.min(min,game.players[i].hp);
				}
				for(var i=0;i<game.players.length;i++){
					if(game.players[i].hp==min&&game.players[i].hp<game.players[i].maxHp) return true;
				}
				return false;
			},
			prompt:function(){
				var targets=[];
				var min=game.players[0].hp;
				for(var i=0;i<game.players.length;i++){
					min=Math.min(min,game.players[i].hp);
				}
				for(var i=0;i<game.players.length;i++){
					if(game.players[i].hp==min&&game.players[i].hp<game.players[i].maxHp){
						targets.push(game.players[i]);
					}
				}
				return '令'+get.translation(targets)+'回复一点体力';
			},
			check:function(card){
				return 8-ai.get.value(card);
			},
			filterTarget:function(card,player,target){
				if(target.hp==target.maxHp) return false;
				for(var i=0;i<game.players.length;i++){
					if(game.players[i].hp<target.hp) return false;
				}
				return true;
			},
			selectTarget:-1,
			content:function(){
				target.recover();
			},
			ai:{
				expose:0.1,
				order:9,
				threaten:1.4,
				result:{
					player:function(player,target){
						var num=0;
						var min=game.players[0].hp;
						for(var i=0;i<game.players.length;i++){
							min=Math.min(min,game.players[i].hp);
						}
						for(var i=0;i<game.players.length;i++){
							if(game.players[i].hp==min&&game.players[i].hp<game.players[i].maxHp){
								num+=ai.get.recoverEffect(game.players[i],player,player);
							}
						}
						return num;
					}
				}
			}
		},
		hzhenwei:{
			trigger:{global:'shaBefore'},
			direct:true,
			priority:5,
			filter:function(event,player){
				if(player==event.target||player==event.player) return false;
				if(!player.num('he')) return false;
				return get.distance(event.player,player,'attack')<=1;
			},
			content:function(){
				"step 0"
				var save=false;
				if(ai.get.attitude(player,trigger.target)>2){
					if(player.num('h','shan')||player.get('e','2')||
					trigger.target.hp==1||player.hp>trigger.target.hp+1){
						if(!trigger.target.num('h','shan')||trigger.target.num('h')<player.num('h')){
							save=true;
						}
					}
				}
				var next=player.chooseToDiscard('he',get.prompt('hzhenwei'));
				next.logSkill=['hzhenwei',trigger.target];
				next.ai=function(card){
					if(save){
						return 7-ai.get.value(card);
					}
					return 0;
				}
				"step 1"
				if(result.bool){
					trigger.target=player;
					trigger.untrigger();
					trigger.trigger('useCardToBefore');
					trigger.trigger('shaBefore');
					player.addSkill('hzhenwei2');
					game.delay();
				}
			},
			ai:{
				effect:{
					target:function(card){
						if(card.name=='sha') return 1.3;
					}
				}
			}
		},
		hzhenwei2:{
			trigger:{target:'shaAfter'},
			forced:true,
			popup:false,
			content:function(){
				player.draw();
				player.removeSkill('hzhenwei2');
			}
		},
		fzhenwei:{
			trigger:{global:'respondEnd'},
			filter:function(event,player){
				if(_status.currentPhase!=player) return false;
				if(event.player==player) return false;
				if(event.cards){
					for(var i=0;i<event.cards.length;i++){
						if(get.position(event.cards[i])=='d') return true;
					}
				}
				return false;
			},
			direct:true,
			content:function(){
				"step 0"
				var cards=trigger.cards.slice(0);
				for(var i=0;i<cards.length;i++){
					if(get.position(cards[i])!='d'){
						cards.splice(i--,1);
					}
				}
				event.cards=cards;
				game.delay(0.5);
				player.chooseTarget(get.prompt('fzhenwei'),function(card,player,target){
					return target!=trigger.player;
				}).ai=function(target){
					var att=ai.get.attitude(player,target);
					if(att<=0) return 0;
					if(att>3){
						return 100-target.num('h');
					}
					return att;
				}
				"step 1"
				if(result.bool){
					player.logSkill('fzhenwei',result.targets);
					result.targets[0].gain(event.cards,'gain2','log');
				}
			},
			ai:{
				expose:0.1,
				threaten:1.6
			}
		},
		shangxi:{
			trigger:{player:'phaseUseBegin'},
			direct:true,
			filter:function(event,player){
				if(player.num('he')==0) return false;
				for(var i=0;i<game.players.length;i++){
					if(game.players[i]!=player&&
						get.distance(player,game.players[i],'attack')<=1&&
						player.hp<=game.players[i].hp){
						return true;
					}
				}
				return false;
			},
			content:function(){
				"step 0"
				var next=player.chooseCardTarget({
					position:'he',
					filterTarget:function(card,player,target){
						return get.distance(player,target,'attack')<=1&&
							player!=target&&player.hp<=target.hp;
					},
					filterCard:lib.filter.cardDiscardable,
					ai1:function(card){
						return 9-ai.get.value(card);
					},
					ai2:function(target){
						return ai.get.damageEffect(target,player,player);
					},
					prompt:get.prompt('shangxi')
				});
				"step 1"
				if(result.bool){
					player.discard(result.cards);
					player.logSkill('shangxi',result.targets);
					result.targets[0].damage();
				}
			},
			ai:{
				expose:0.3
			}
		},
		fuyan:{
			trigger:{player:'damageEnd'},
			direct:true,
			filter:function(event){
				return event.num>0;
			},
			content:function(){
				"step 0"
				player.chooseTarget(get.prompt('fuyan'),function(card,player,target){
					return !target.hujia;
				}).ai=function(target){
					if(ai.get.attitude(player,target)<=0) return 0;
					var eff=-ai.get.damageEffect(target,target,player)+(player==target?2:0);
					if(target.hp==1) eff+=2;
					return Math.min(1,eff);
				};
				"step 1"
				if(result.bool){
					player.logSkill('fuyan',result.targets);
					var target=result.targets[0];
					target.changeHujia();
				}
			},
			ai:{
				effect:{
					target:function(card,player){
						if(get.tag(card,'damage')){
							if(player.hasSkill('jueqing')) return [1,-2];
							return 0.7;
						}
					}
				},
				expose:0.2
			}
		},
		fuyan2:{
			trigger:{player:'damageBegin'},
			filter:function(event,player){
				return event.num>0;
			},
			forced:true,
			mark:'card',
			content:function(){
				trigger.num--;
				player.removeSkill('fuyan2');
				ui.discardPile.appendChild(player.storage.fuyan2);
				delete player.storage.fuyan2;
			},
			intro:{
				content:'card'
			}
		},
		pingshen:{
			trigger:{source:'damageBegin'},
			forced:true,
			popup:false,
			unique:true,
			silent:true,
			content:function(){
				trigger.player.addSkill('pingshen2');
				trigger.player.storage.pingshen=player;
			}
		},
		pingshen2:{
			enable:'phaseUse',
			unique:true,
			mark:true,
			init:function(player){
				player.storage.pingshen2=false;
			},
			filter:function(event,player){
				return !player.storage.pingshen2&&player.storage.pingshen.isAlive();
			},
			filterCard:true,
			filterTarget:function(card,player,target){
				return target==player.storage.pingshen;
			},
			selectTarget:-1,
			position:'he',
			content:function(){
				player.storage.pingshen2=true;
				player.unmarkSkill('pingshen2');
				player.gain(target.get('h'),target);
				target.$give(target.num('h'),player);
				player.turnOver();
				player.addSkill('pingshen3');
			},
			check:function(card){return 8-ai.get.value(card);},
			intro:{
				content:'limited'
			},
			ai:{
				order:10,
				result:{
					player:function(player){
						if(player.classList.contains('turnedover')) return 10;
						if(ai.get.attitude(player,player.storage.pingshen)>=0){
							return 0;
						}
						if(player.storage.pingshen.num('h')>player.storage.pingshen.hp) return 1;
						return 0;
					}
				},
				effect:{
					target:function(card,player,target){
						if(!target.storage.pingshen2){
							if(card.name=='guiyoujie') return [0,1];
						}
					}
				}
			},
		},
		pingshen3:{
			trigger:{player:'phaseUseEnd'},
			forced:true,
			popup:false,
			content:function(){
				"step 0"
				player.removeSkill('pingshen3');
				if(player.storage.pingshen.classList.contains('dead')){
					event.finish();
				}
				else{
					player.chooseCard('he',true,player.storage.pingshen.hp);
				}
				"step 1"
				player.storage.pingshen.gain(result.cards,player);
				player.$give(result.cards.length,player.storage.pingshen);
			}
		},
        guaili:{
			trigger:{source:'damageBegin'},
			filter:function(event){
				return event.card&&event.card.name=='sha'&&event.parent.name!='_lianhuan'&&event.parent.name!='_lianhuan2';
			},
			forced:true,
			content:function(){
				trigger.num++;
                player.addSkill('guaili2');
			}
		},
        guaili2:{
            trigger:{source:'damageEnd'},
            forced:true,
            popup:false,
            content:function(){
                player.removeSkill('guaili2');
                player.chooseToDiscard(2,true);
            }
        },
		xingzhui:{
			enable:'phaseUse',
			usable:1,
			filterCard:true,
			position:'he',
			filterTarget:function(card,player,target){
				return player!=target&&target.num('he')>0;
			},
			check:function(card){
				if(get.type(card)=='equip'){
					var distance=get.info(card).distance;
					if(distance){
						if(distance.attackFrom<0||distance.globalFrom<0) return 10;
					}
				}
				return 7-ai.get.value(card);
			},
			content:function(){
				"step 0"
				event.type=get.type(cards[0],'trick');
				var dme=ai.get.damageEffect(target,player,target);
				target.chooseToDiscard('he',function(card){
					return get.type(card,'trick')==event.type;
				},'弃置一张牌'+get.translation(event.type)+'牌，或受到1点伤害').ai=function(card){
					if(dme<0){
						return 8-ai.get.value(card);
					}
					return 0;
				}
				"step 1"
				if(!result.bool){
					target.damage();
				}
			},
			ai:{
				order:9,
				result:{
					target:function(player,target){
						return ai.get.damageEffect(target,player);
					}
				},
				threaten:2,
				expose:0.2
			}
		},
		lingxian:{
			trigger:{player:['respond','useCard']},
			direct:true,
			filter:function(event,player){
				if(player==_status.currentPhase) return false;
				if(get.itemtype(event.cards)!='cards') return false;
				for(var i=0;i<game.players.length;i++){
					if(get.distance(player,game.players[i],'attack')>1&&player!=game.players[i]){
						return true;
					}
				}
				return false;
			},
			content:function(){
				"step 0"
				player.chooseTarget(get.prompt('lingxian'),function(card,player,target){
					return get.distance(player,target,'attack')>1&&player!=target;
				}).ai=function(target){
					var att=ai.get.attitude(player,target);
					if(att<=-0.5) return 0;
					if(att<=3) return att+0.5;
					return att+Math.min(0.5,5-target.num('h'));
				}
				"step 1"
				if(result.bool){
					game.asyncDraw([player,result.targets[0]]);
					player.logSkill('lingxian',result.targets);
				}
			},
			ai:{
				mingzhi:false,
				effect:{
					target:function(card,player,target){
						if(get.type(card)=='equip'&&player==target){
							var distance=get.info(card).distance;
							if(distance){
								if(distance.attackFrom<0||distance.globalFrom<0) return 0;
							}
						}
						else{
							var hasFriend=false;
							for(var i=0;i<game.players.length;i++){
								if(get.distance(player,game.players[i],'attack')>1&&
								player!=game.players[i]&&ai.get.attitude(player,game.players[i]>0)){
									hasFriend=true;break;
								}
							}
							if(!hasFriend) return;
							var hs=target.num('h');
							if(get.tag(card,'respondShan')){
								var shans=target.num('h','shan');
								if(shans>1) return [0,1];
								if(shans&&hs>2) return [0,1];
								if(shans) return [0,0];
								if(hs>2) return [0,0];
								if(hs>1) return [1,0.5];
								return [1.5,0];
							}
							if(get.tag(card,'respondSha')){
								var shas=target.num('h','sha');
								if(shas>1) return [0,1];
								if(shas&&hs>2) return [0,1];
								if(shas) return [0,0];
								if(hs>2) return [0,0];
								if(hs>1) return [1,0.5];
								return [1.5,0];
							}
						}
					}
				},
				threaten:0.8,
				expose:0.1
			}
		},
		shouyin:{
			skillAnimation:'epic',
			animationColor:'water',
			unique:true,
			enable:'chooseToUse',
			init:function(player){
				player.storage.shouyin=false;
			},
			mark:true,
			filter:function(event,player){
				if(event.type!='dying') return false;
				if(player.storage.shouyin) return false;
				if(player.isTurnedOver()) return false;
				return true;
			},
			content:function(){
				"step 0"
				player.awakenSkill('shouyin');
				player.storage.shouyin=true;
				player.turnOver();
				"step 1"
				event.targets=game.players.slice(0);
				event.targets.sort(lib.sort.seat);
				"step 2"
				if(event.targets.length){
					var target=event.targets.shift();
					if(target.hp<target.maxHp){
						target.recover(target.maxHp-target.hp);
					}
					event.redo();
				}
			},
			ai:{
				skillTagFilter:function(player){
					if(player.storage.shouyin) return false;
				},
				expose:0.3,
				save:true,
				result:{
					player:function(player){
						if(_status.dying!=player&&ai.get.attitude(player,_status.dying)<=0){
							return 0;
						}
						var num=0;
						for(var i=0;i<game.players.length;i++){
							var att=ai.get.attitude(player,game.players[i]);
							var del=game.players[i].maxHp-game.players[i].hp;
							if(att>0){
								num+=del;
							}
							else if(att<0){
								num-=del;
							}
						}
						return num;
					}
				}
			},
			intro:{
				content:'limited'
			}
		},
		sliufeng:{
			mod:{
				targetInRange:function(card,player,target){
					if(card.name=='sha'&&player.hp>=target.hp){
						return true;
					}
				}
			},
		},
		linyun:{
			enable:'chooseToUse',
			filterCard:true,
			selectCard:2,
			position:'he',
			viewAs:{name:'sha'},
			prompt:'将两张牌当杀使用',
			check:function(card){
				if(_status.event.player.num('h')<4) return 6-ai.get.useful(card);
				return 7-ai.get.useful(card);
			},
			ai:{
				order:function(){
					return lib.card.sha.ai.order+0.1;
				}
			},
			group:['linyun2']
		},
		linyun2:{
			trigger:{player:'shaBegin'},
			filter:function(event){
				return event.skill=='linyun'
			},
			forced:true,
			popup:false,
			content:function(){
				"step 0"
				var next=trigger.target.chooseToRespond({name:'shan'});
				next.autochoose=lib.filter.autoRespondShan;
				next.ai=function(card){
					if(trigger.target.num('h','shan')>1){
						return ai.get.unuseful2(card);
					}
					return -1;
				};
				"step 1"
				if(result.bool==false){
					trigger.untrigger();
					trigger.directHit=true;
				}
			},
			ai:{
				threaten:1.3
			}
		},
		linyun3:{
			trigger:{source:'damageAfter'},
			forced:true,
			popup:false,
			filter:function(event,player){
				return event.parent.skill=='linyun'&&!player.hasSkill('linyun4');
			},
			content:function(){
				player.draw();
				player.addTempSkill('linyun4','shaAfter')
			}
		},
		linyun4:[],
		bofeng:{
			mod:{
				targetInRange:function(card,player,target){
					if(card.name=='sha'&&player.hp>=target.hp){
						return true;
					}
				}
			},
			trigger:{player:'shaBegin'},
			check:function(event,player){
				return ai.get.attitude(player,event.target)<0;
			},
			content:function(){
				"step 0"
				trigger.target.chooseToRespond({name:'shan'});
				"step 1"
				if(result.bool==false){
					trigger.untrigger();
					trigger.directHit=true;
					player.addTempSkill('bofeng2','shaEnd');
				}
			},
			ai:{
				threaten:1.3
			}
		},
		bofeng2:{
			trigger:{source:'damageBegin'},
			filter:function(event){
				return (event.card&&(event.card.name=='sha')&&event.parent.name!='_lianhuan'&&event.parent.name!='_lianhuan2');
			},
			forced:true,
			popup:false,
			content:function(){
				trigger.num++;
			},
		},
		hutian:{
			trigger:{player:'phaseEnd'},
			direct:true,
			filter:function(event,player){
				return player.num('h')>0&&!player.storage.hutian;
			},
			content:function(){
				"step 0"
				var next=player.chooseCardTarget({
					filterTarget:function(card,player,target){
						return target.maxHp>=ui.selected.cards.length;
					},
					filterCard:true,
					selectCard:[1,Infinity],
					ai1:function(card){
						var useful=ai.get.useful(card);
						if(card.name=='du'){
							useful=-5;
						}
						if(ui.selected.cards.length==0&&player.hp==1) return 11-useful;
						if(ui.selected.cards.length>1) return 0;
						return 7-useful;
					},
					ai2:function(target){
						if(target.hp>ui.selected.cards.length){
							return 0;
						}
						return ai.get.attitude(player,target);
					},
					prompt:get.prompt('hutian')
				});
				"step 1"
				if(result.bool){
					var target=result.targets[0];
					event.target=target;
					player.$give(result.cards,target);
					player.lose(result.cards,ui.special);
					player.storage.hutian=target;
					player.logSkill('hutian',result.targets);
					player.addTempSkill('hutian4','phaseAfter');
					target.addSkill('hutian2');
					target.storage.hutian2=result.cards;
					game.addVideo('storage',target,['hutian2',get.cardsInfo(result.cards),'cards']);
				}
				else{
					event.finish();
				}
				"step 2"
				var target=event.target;
				if(target.storage.hutian2&&target.hp<target.storage.hutian2.length){
					target.recover(target.storage.hutian2.length-target.hp);
				}
			},
			ai:{
				expose:0.2,
				threaten:1.5
			},
			group:'hutian3'
		},
		hutian2:{
			trigger:{player:['damageBegin','loseHpBegin']},
			forced:true,
			priority:-55,
			mark:true,
			filter:function(event,player){
				return player.hp-event.num<player.storage.hutian2.length;
			},
			content:function(){
				trigger.num=player.hp-player.storage.hutian2.length;
			},
			intro:{
				content:'cards'
			},
			ai:{
				effect:{
					target:function(card,player,target){
						if(get.tag(card,'damage')||get.tag(card,'loseHp')){
							if(target.hp<=target.storage.hutian2.length) return 0;
						}
					}
				}
			}
		},
		hutian3:{
			trigger:{player:['phaseEnd','dieBegin']},
			forced:true,
			filter:function(event,player){
				if(player.hasSkill('hutian4')) return false;
				return player.storage.hutian?true:false;
			},
			priority:-1,
			content:function(){
				var target=player.storage.hutian;
				target.gain(target.storage.hutian2,'gain2');
				delete target.storage.hutian2;
				delete player.storage.hutian;
				target.removeSkill('hutian2');
			}
		},
		hutian4:{},
		chengjian:{
			trigger:{global:'damageEnd'},
			check:function(event,player){
				return ai.get.attitude(player,event.source)>0;
			},
			filter:function(event,player){
				return event.source&&event.card&&event.card.name=='sha'&&event.source!=player;
			},
			content:function(){
                player.line(trigger.source,'green');
				trigger.source.draw();
			},
			ai:{
				expose:0.1,
				threaten:1.2
			}
		},
		huanxing:{
			trigger:{player:'phaseBegin'},
			group:'huanxing2',
			direct:true,
			content:function(){
				"step 0"
				if(player.num('he')){
					player.chooseCardTarget({
						prompt:get.prompt('huanxing'),
						filterCard:lib.filter.cardDiscardable,
						position:'he',
						filterTarget:function(card,player,target){
							if(target==player) return false;
							if(target.sex!='male') return false;
							var name=target.name.indexOf('unknown')==0?target.name2:target.name;
							if(name==player.storage.huanxing) return false;

							var info=lib.character[name];
							if(info){
								var skills=info[3];
								for(var j=0;j<skills.length;j++){
									if(lib.translate[skills[j]+'_info']&&lib.skill[skills[j]]&&
										!lib.skill[skills[j]].unique&&!player.hasSkill(skills[j])){
										return true;
									}
								}
							}
							return false;
						},
						ai1:function(card){
							if(player.additionalSkills.huanxing&&player.additionalSkills.huanxing.length>0) return 0;
							return 7-ai.get.value(card);
						},
						ai2:function(target){
							if(target.isMin()) return 0;
							return 6-target.maxHp;
						}
					});
				}
				else{
					event.finish();
				}
				"step 1"
				if(result.bool){
					player.unmark(player.storage.huanxing+'_charactermark');
					player.discard(result.cards);
					player.logSkill('huanxing',result.targets);
					var name=result.targets[0].name;
					if(name.indexOf('unknown')==0){
						name=result.targets[0].name2;
					}
					var list=[];
					var skills=lib.character[name][3];
					for(var j=0;j<skills.length;j++){
						if(lib.translate[skills[j]+'_info']&&lib.skill[skills[j]]&&
							!lib.skill[skills[j]].unique&&!player.hasSkill(skills[j])){
							list.push(skills[j]);
						}
					}
					player.addAdditionalSkill('huanxing',list);
					player.markCharacter(name,null,true,true);
					game.addVideo('markCharacter',player,{
						name:'幻形',
						content:'',
						id:'huanxing',
						target:name
					});
					player.storage.huanxing=name;
				}
			},
			ai:{
				threaten:1.5
			}
		},
		huanxing2:{
			trigger:{player:'damageAfter'},
			priority:-15,
			forced:true,
			filter:function(event,player){
				return player.additionalSkills.huanxing&&player.additionalSkills.huanxing.length>0;
			},
			content:function(){
				player.unmark(player.storage.huanxing+'_charactermark');
				player.removeAdditionalSkill('huanxing');
				delete player.storage.huanxing;
				player.checkMarks();
			}
		},
		guiying:{
			enable:'chooseToUse',
			filterCard:{color:'black'},
			position:'he',
			viewAs:{name:'toulianghuanzhu'},
			prompt:'将一张黑色牌当作偷梁换柱使用',
			check:function(card){
				if(_status.event.player.num('h')>_status.event.player.hp){
					return 5-ai.get.value(card)
				}
				return 0;
			},
		},
		suiyan:{
			trigger:{source:'damageEnd'},
			// group:'unequip',
			check:function(event,player){
				return ai.get.attitude(player,event.player)<0;
			},
			direct:true,
			filter:function(event,player){
				return event.player.num('e');
			},
			content:function(){
				"step 0"
				var att=ai.get.attitude(player,trigger.player);
				var next=player.chooseToDiscard('he',get.prompt('suiyan'));
				next.ai=function(card){
					if(att<0) return 7-ai.get.value(card);
					return -1;
				}
				next.logSkill=['suiyan',trigger.player];
				"step 1"
				if(result.bool){
					trigger.player.discard(trigger.player.get('e'));
				}
			},
			ai:{
				expose:0.3
			},
		},
		ningxian:{
			trigger:{player:'damageEnd'},
			direct:true,
			filter:function(event,player){
				return player.num('he',{color:'black'})>0;
			},
			content:function(){
				"step 0"
				var enemy=0;
				for(var i=0;i<game.players.length;i++){
					if(game.players[i]!=player&&ai.get.damageEffect(game.players[i],player,player)>0){
						enemy++;
					}
				}
				var next=player.chooseCardTarget({
					position:'he',
					filterTarget:function(card,player,target){
						return player!=target;
					},
					selectCard:[1,player.num('he',{color:'black'})],
					selectTarget:function(){
						if(ui.selected.targets.length>ui.selected.cards.length){
							game.uncheck('target');
						}
						return ui.selected.cards.length;
					},
					filterCard:function(card,player){
						return get.color(card)=='black'&&lib.filter.cardDiscardable(card,player);
					},
					ai1:function(card){
						if(ui.selected.cards.length>=enemy) return 0;
						return 9-ai.get.value(card);
					},
					ai2:function(target){
						return ai.get.damageEffect(target,player,player);
					},
					prompt:get.prompt('ningxian')
				});
				"step 1"
				if(result.bool){
					player.discard(result.cards);
					player.logSkill('ningxian',result.targets);
					event.targets=result.targets;
					event.targets.sort(lib.sort.seat);
				}
				else{
					event.finish();
				}
				"step 2"
				if(event.targets.length){
					event.targets.shift().damage();
					event.redo();
				}
			},
			ai:{
				maixie:true,
				effect:function(card,player,target){
					if(get.tag(card,'damage')){
						if(player.hasSkill('jueqing')) return [1,-0.5];
						if(!target.hasFriend()){
							if(lib.config.mode=='guozhan'){
								if(!player.hasFriend()) return;
							}
							else{
								return;
							}
						}
						if(target.num('h')>2||target.num('e',{color:'black'})){
							return [1,0,0,-1];
						}
						return [1,-0.5];
					}
				},
			}
		},
		xuanyuan:{
			trigger:{global:'discardAfter'},
			filter:function(event,player){
				if(event.player==player) return false;
				for(var i=0;i<event.cards.length;i++){
					if(event.cards[i].name=='xuanyuanjian'&&get.position(event.cards[i])=='d'){
						return true;
					}
				}
				return false;
			},
			frequent:true,
			content:function(){
				"step 0"
				if(trigger.delay==false) game.delay();
				"step 1"
				var cards=[];
				for(var i=0;i<trigger.cards.length;i++){
					if(event.cards[i].name=='xuanyuanjian'&&get.position(trigger.cards[i])=='d'){
						cards.push(trigger.cards[i]);
					}
				}
				if(cards.length){
					player.gain(cards);
					player.$gain2(cards);
					game.log(player,'发动','【轩辕】','，获得了',cards);
				}
			},
		},
		jilve:{
			enable:'phaseUse',
			group:'jilve6',
			direct:true,
			usable:3,
			delay:0,
			content:function(){
				"step 0"
				player.getStat('skill').jilve--;
				var cards=[];
				var max=Math.min(2,ui.cardPile.childNodes.length);
				for(var i=0;i<max;i++){
					cards.push(ui.cardPile.childNodes[i]);
				}
				for(var i=max;i<2;i++){
					cards.push(ui.discardPile.childNodes[i]);
				}
				var dialog=ui.create.dialog('极略：选择一张基本牌或锦囊牌牌使用',cards);
				var trigger=event.parent.parent;
				player.chooseButton(dialog,function(card){if(card.name=='du') return 0;return 1}).filterButton=function(button){
					var type=get.type(button.link,'trick');
					return (type=='trick'||type=='basic')&&trigger.filterCard(button.link,player,trigger);
				};
				player.addTempSkill('jilve3',['useCardAfter','phaseAfter']);
				"step 1"
				if(result.bool){
					// player.getStat('skill').jilve++;
					lib.skill.jilve2.viewAs=result.buttons[0].link;
					event.parent.parent.backup('jilve2');
					event.parent.parent.step=0;
					if(event.isMine()){
						event.parent.parent.openskilldialog='选择'+get.translation(result.buttons[0].link)+'的目标';
					}
				}
			},
			ai:{
				order:12,
				result:{
					player:function(player){
						if(player.tempSkills.jilve3) return 0;
						if(_status.dying) return ai.get.attitude(player,_status.dying);
						return 1;
					}
				},
				threaten:1.7
			}
		},
		jilve6:{
			trigger:{player:'useCardBefore'},
			forced:true,
			popup:false,
			filter:function(event,player){
				return event.skill=='jilve2';
			},
			content:function(){
				player.getStat('skill').jilve++;
			}
		},
		jilve2:{
			filterCard:function(){return false},
			selectCard:-1
		},
		jilve3:{},
		jilve4:{
			trigger:{player:'useCard'},
			forced:true,
			popup:false,
			filter:function(event){
				return event.skill=='jilve2';
			},
			content:function(){
				player.storage.jilve++;
			}
		},
		jilve5:{
			trigger:{player:'phaseUseBegin'},
			forced:true,
			popup:false,
			content:function(){
				player.storage.jilve=0;
			}
		},
		pozhou:{
			unique:true,
			trigger:{player:'damageEnd'},
			forced:true,
			init:function(player){
				player.storage.pozhou=0;
			},
			content:function(){
				player.storage.pozhou+=trigger.num;
				if(player.storage.pozhou){
					player.markSkill('pozhou');
				}
				game.addVideo('storage',player,['pozhou',player.storage.pozhou]);
			},
			intro:{
				content:'mark'
			},
			group:'pozhou2',
			ai:{
				maixie:true,
				effect:{
					target:function(card,player,target){
						if(get.tag(card,'damage')){
							if(player.hasSkill('jueqing')) return [1,-1.5];
							if(player.hp>=4) return [1,1.5];
							if(target.hp==3) return [1,1];
							if(target.hp==2) return [1,0.5];
						}
					}
				}
			}
		},
		pozhou2:{
			enable:'phaseUse',
			filter:function(event,player){
				return player.storage.pozhou>0;
			},
			filterTarget:function(card,player,target){
				return target!=player&&!target.hasSkill('fengyin');
			},
			selectTarget:function(){
				return [1,_status.event.player.storage.pozhou];
			},
			prompt:'出牌阶段，你可以指定任意名其他角色并弃置等量的破咒标记，令目标的非锁定技失效直到其下一回合结束',
			content:function(){
				player.storage.pozhou--;
				if(!player.storage.pozhou){
					player.unmarkSkill('pozhou');
				}
				else{
					player.updateMarks();
				}
				target.addTempSkill('fengyin',{player:'phaseAfter'});
			},
			ai:{
				order:11,
				result:{
					target:function(player,target){
						var skills=target.get('s');
						for(var i=0;i<skills.length;i++){
							if(!get.is.locked(skills[i])){
								if(target.hasSkillTag('maixie')) return -2;
								return -ai.get.threaten(target);
							}
						}
						return 0;
					}
				}
			}
		},
		pozhou2_old:{
			trigger:{global:'phaseBegin'},
			priority:-5,
			check:function(event,player){
				if(event.player.isMin()) return false;
				return ai.get.attitude(player,event.player)<-3;
			},
			filter:function(event,player){
				return player.storage.pozhou>0&&player!=event.player;
			},
			prompt:function(event,player){
				return '是否弃置一枚破咒标记令'+get.translation(event.player)+
				'的非锁定技失效？（剩余'+player.storage.pozhou+'枚）';
			},
			logTarget:'player',
			content:function(){
				player.storage.pozhou--;
				if(!player.storage.pozhou){
					player.unmarkSkill('pozhou');
				}
				else{
					player.updateMarks();
				}
				trigger.player.addTempSkill('fengyin',{player:'phaseBegin'});
			}
		},
		fengmo:{
			enable:'phaseUse',
			usable:1,
			filter:function(){
				var num=0
				for(var i=0;i<game.players.length;i++){
					if(game.players[i].get('e','1')){
						num++;
					}
				}
				return num>=1;
			},
			filterTarget:function(card,player,target){
				return player!=target&&!target.isTurnedOver();
			},
			content:function(){
				"step 0"
				event.targets=[];
				event.num=0;
				for(var i=0;i<game.players.length;i++){
					if(game.players[i].get('e','1')){
						event.targets.push(game.players[i]);
					}
				}
				event.targets.sort(lib.sort.seat);
				"step 1"
				if(num<event.targets.length){
					var targetn=event.targets[num];
					var card=targetn.get('e','1');
					if(card){
						targetn.discard(card);
					}
					event.num++;
					event.redo();
				}
				"step 2"
				target.draw(event.targets.length);
				"step 3"
				target.turnOver();
			},
			ai:{
				result:{
					target:function(player,target){
						var num=0
						for(var i=0;i<game.players.length;i++){
							if(game.players[i].get('e','1')){
								num++;
							}
						}
						if(target.hp==1&&num<3){
							return (num-3)/1.5;
						}
						return num-3;
					}
				},
				order:10,
				expose:0.1
			}
		},
		duanyue:{
			enable:'phaseUse',
			usable:1,
			position:'he',
			filterCard:{type:'equip'},
			check:function(card){
				var player=_status.currentPhase;
				if(player.num('he',{subtype:get.subtype(card)})>1){
					return 12-ai.get.equipValue(card);
				}
				return 8-ai.get.equipValue(card);
			},
			filter:function(event,player){
				return player.num('he',{type:'equip'});
			},
			filterTarget:function(card,player,target){
				return player!=target;
			},
			content:function(){
				"step 0"
				target.damage();
				"step 1"
				if(target.isAlive()){
					var cards=target.get('h');
					event.num=cards.length;
					target.discard(cards);
				}
				else{
					event.finish();
				}
				"step 2"
				if(event.num>=2){
					player.loseHp();
				}
			},
			ai:{
				order:9.5,
				expose:0.2,
				result:{
					target:function(player,target){
						if(ai.get.damageEffect(target,player)<0){
							return -target.num('h')-(target.hp==1?1:0);
						}
					}
				}
			}
		},
		mojian:{
			trigger:{player:'shaBegin'},
			check:function(event,player){
				if(ai.get.attitude(player,event.target)>0) return true;
				return player.hp<player.maxHp;
			},
			// filter:function(event){
			// 	return event.player.isAlive();
			// },
			content:function(){
				"step 0"
				trigger.target.draw();
				"step 1"
				player.recover();
			}
		},
		liuhong:{
			trigger:{player:['useCard']},
			frequent:true,
			filter:function(event){
				return event.card&&event.card.name=='sha';
			},
			content:function(){
				player.draw();
			}
		},
		poyue:{
			mod:{
				targetInRange:function(card,player){
					if(card.name=='sha'&&get.color(card)=='black') return true;
				},
				cardUsable:function(card){
					if(card.name=='sha'&&get.color(card)=='red') return Infinity;
				}
			},
			trigger:{player:'useCard'},
			filter:function(event,player){
				return event.card.name=='sha'&&get.color(event.card)=='red';
			},
			forced:true,
			content:function(){
				if(player.stat[player.stat.length-1].card.sha>0){
					player.stat[player.stat.length-1].card.sha--;
				}
			},
			group:'poyue2'
		},
		poyue2:{
			trigger:{player:'shaBegin'},
			forced:true,
			popup:false,
			filter:function(event,player){
				return event.card&&get.color(event.card)=='red';
			},
			content:function(){
				trigger.directHit=true;
			}
		},
		jianji:{
			enable:'phaseUse',
			filter:function(event,player){
				return player.num('he',{type:'equip'})>0&&lib.filter.cardEnabled({name:'sha'},player);
			},
			usable:1,
			filterCard:{type:'equip'},
			position:'he',
			check:function(card){
				var player=_status.currentPhase;
				if(player.num('he',{subtype:get.subtype(card)})>1){
					return 11-ai.get.equipValue(card);
				}
				return 6-ai.get.equipValue(card);
			},
			discard:false,
			prepare:'throw',
			delay:false,
			filterTarget:function(card,player,target){
				return lib.filter.targetEnabled({name:'sha'},player,target);
			},
			content:function(){
				"step 0"
				if(!player.hasSkill('unequip')){
					event.added=true
					player.skills.push('unequip');
				}
				player.draw();
				player.useCard({name:'sha'},cards,targets,'jianji',false).animate=false;
				player.line(targets,'fire');
				"step 1"
				if(event.added){
					player.skills.remove('unequip');
				}
			},
			ai:{
				order:function(){
					return lib.card.sha.ai.order+0.1;
				},
				result:{
					target:function(player,target){
						var added=false;
						if(!player.hasSkill('unequip')){
							added=true;
							player.skills.push('unequip');
						}
						var eff=ai.get.effect(target,{name:'sha'},player,target);
						if(added){
							player.skills.remove('unequip');
						}
						return eff;
					}
				},
				effect:{
					player:function(card,player){
						if(_status.currentPhase!=player) return;
						if(get.type(card)=='equip'&&
							player.num('e',{subtype:get.subtype(card)})&&
							lib.filter.filterCard({name:'sha'},player)){
							return 0;
						}
					}
				},
				threaten:1.3
			}
		},
		huangyu:{
			enable:'phaseUse',
			filter:function(event,player){
				if(!lib.card.chiyuxi) return false;
				return !player.getStat('skill').huangyu&&player.num('he',{color:'red'})>1;
			},
			filterCard:{color:'red'},
			selectCard:2,
			position:'he',
			viewAs:{name:'chiyuxi',nature:'fire'},
			check:function(card){
				var player=_status.event.player;
				if(player.hasSkill('jianji')&&get.type(card)=='equip'&&
					lib.filter.filterCard({name:'sha'},player)){
					return 0;
				}
				return 6-ai.get.value(card)
			},
			ai:{
				order:8,
				expose:0.2,
				threaten:1.2
			}
		},
		gongshen:{
			trigger:{global:'useCard'},
			priority:15,
			filter:function(event,player){
				var type=get.type(event.card,'trick');
				if(type!='basic'&&type!='trick') return false;
				return event.player!=player&&player.num('he',{type:'equip'})>0&&
					event.targets&&event.targets.length>0;
			},
			direct:true,
			content:function(){
				"step 0"
				var effect=0;
				for(var i=0;i<trigger.targets.length;i++){
					effect+=ai.get.effect(trigger.targets[i],trigger.card,trigger.player,player);
				}
				var str='是否弃置一张装备牌令'+get.translation(trigger.player);
				if(trigger.targets&&trigger.targets.length){
					str+='对'+get.translation(trigger.targets);
				}
				str+='的'+get.translation(trigger.card)+'失效？'
				var next=player.chooseToDiscard('he',{type:'equip'},str);
				next.logSkill='gongshen';
				next.ai=function(card){
					if(effect<0){
						var val=9-ai.get.value(card);
						var nme=trigger.card.name;
						if(nme=='tao') return val;
						if(nme=='shunshou'&&player==trigger.targets[0]) return val;
						if(nme=='liuxinghuoyu') return val;
						if(nme=='nanman') return val;
						if(nme=='wanjian') return val;
						if(nme=='jingleishan') return val;
						if(nme=='chiyuxi') return val;
						if((nme=='juedou')&&(player==trigger.targets[0]||trigger.targets[0].hp==1)) return val;
						if(nme=='chenhuodajie') return val;
						if(nme=='lebu'&&trigger.targets[0].num('h')>trigger.targets[0].hp) return val;
						if(nme=='sha'&&trigger.targets[0].hp==1&&!trigger.targets[0].num('h','shan')) return val;
						if(nme=='jiedao'&&trigger.targets[0]==player) return val;
						if(nme=='yihuajiemu'&&trigger.targets[0]==player) return val;
						if(nme=='shuiyanqijun'&&trigger.targets.contains(player)) return val;
						return 0;
					}
					return -1;
				}
				"step 1"
				if(result.bool){
					game.delay(2);
					trigger.untrigger();
					trigger.finish();
				}
				else{
					event.finish();
				}
				"step 2"
				ui.clear();
			},
			ai:{
				effect:{
					player:function(card,player,target){
						if(player!=target) return;
						if(get.type(card)=='equip'&&player.num('h')<=player.hp){
							return [0,0,0,0];
						}
					}
				},
				threaten:2,
				expose:0.3
			}
		},
		xiaozhan:{
			trigger:{global:'useCard'},
			priority:15,
			filter:function(event,player){
				return event.card.name=='sha'&&event.player!=player&&
					player.num('h','sha')>0&&event.targets.contains(player)==false;
			},
			direct:true,
			content:function(){
				"step 0"
				var effect=0;
				for(var i=0;i<trigger.targets.length;i++){
					effect+=ai.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)+'失效？'
				player.chooseToDiscard('h',{name:'sha'},str).ai=function(card){
					if(effect<0){
						return 9-ai.get.value(card);
					}
					return -1;
				}
				"step 1"
				if(result.bool){
					trigger.untrigger();
					trigger.finish();
					player.logSkill('xiaozhan');
				}
			},
			ai:{
				threaten:1.2,
				expose:0.1
			}
		},
		chuanyue:{
			enable:'phaseUse',
			usable:1,
			filter:function(event,player){
				return player.num('h')>0;
			},
			selectCard:2,
			filterCard:true,
			discard:false,
			prepare:'throw',
			filterTarget:function(card,player,target){
				return lib.filter.targetEnabled({name:'juedou'},player,target);
			},
			check:function(card){
				return Math.max(7-ai.get.value(card),7-ai.get.useful(card));
			},
			content:function(){
				player.useCard({name:'juedou'},targets,cards).animate=false;
			},
			ai:{
				result:{
					target:function(player,target){
						return ai.get.effect(target,{name:'juedou'},player,target);
					}
				},
				order:8,
			}
		},
		yiesheng:{
			enable:'phaseUse',
			filterCard:{color:'black'},
			filter:function(event,player){
				return player.num('h',{color:'black'})>0;
			},
			selectCard:[1,Infinity],
			prompt:'弃置任意张黑色手牌并摸等量的牌',
			check:function(card){return 5-ai.get.value(card)},
			content:function(){
				player.draw(cards.length);
			},
			ai:{
				order:1,
				result:{
					player:1
				},
			},
		},
		dangping:{
			trigger:{source:'damageAfter'},
			direct:true,
			filter:function(event,player){
				return event.parent.name!='dangping'&&!player.hasSkill('dangping2')&&player.num('he')>0;
			},
			content:function(){
				"step 0"
				var next=player.chooseCardTarget({
					position:'he',
					filterTarget:function(card,player,target){
						return player!=target&&trigger.player!=target&&get.distance(trigger.player,target)<=1;
					},
					filterCard:lib.filter.cardDiscardable,
					ai1:function(card){
						return ai.get.unuseful(card)+9;
					},
					ai2:function(target){
						return ai.get.damageEffect(target,player,player);
					},
					prompt:get.prompt('dangping')
				});
				"step 1"
				if(result.bool){
					player.discard(result.cards);
					player.logSkill('dangping',result.targets);
					player.addTempSkill('dangping2','phaseAfter');
				}
				"step 2"
				if(result.bool){
					result.targets[0].damage();
				}
			}
		},
		dangping2:{},
		duishi:{
			enable:'phaseUse',
			filter:function(event,player){
				return player.num('h')>0&&!player.hasSkill('duishi2');
			},
			filterTarget:function(card,player,target){
				return player!=target&&target.num('h')>0&&!target.hasSkill('duishi3');
			},
			filterCard:true,
			check:function(card){return 8-ai.get.value(card)},
			content:function(){
				"step 0"
				var suit=get.suit(cards[0]);
				target.chooseToDiscard({suit:suit},'h','对诗：弃置一张'+get.translation(suit)+
					'牌，或令'+get.translation(player)+'获得你一张牌').ai=function(card){
					if(ai.get.attitude(target,player)>0) return 0;
					return 9-ai.get.value(card);
				}

				"step 1"
				if(result.bool){
					target.addTempSkill('duishi3','phaseAfter');
				}
				else{
					player.gainPlayerCard(target,'he',true);
					player.addTempSkill('duishi2','phaseAfter');
				}
			},
			ai:{
				order:9,
				threaten:1.5,
				result:{
					target:-2,
					player:0.5
				},
				expose:0.2
			}
		},
		duishi2:{},
		duishi3:{},
		guisi:{
			trigger:{target:'shaBefore'},
			popup:false,
			direct:true,
			filter:function(event,player){
				return player.num('h');
			},
			content:function(){
				"step 0"
				player.chooseCard('是否交给'+get.translation(trigger.player)+'一张牌并取消此杀？').ai=function(card){
					if(ai.get.attitude(player,trigger.player)>0){
						return 9-ai.get.value(card);
					}
					if(player.num('h',{name:'shan'})) return -1;
					return 7-ai.get.value(card);
				}
				"step 1"
				if(result.bool){
					player.logSkill('guisi');
					trigger.player.gain(result.cards,player);
					player.$give(result.cards,trigger.player);
					trigger.untrigger();
					trigger.finish();
				}
			},
		},
		lianwu:{
			mod:{
				selectTarget:function(card,player,range){
					if(card.name=='sha'&&range[1]!=-1) range[1]++;
				},
			},
			trigger:{player:'shaBegin'},
			forced:true,
			filter:function(event,player){
				return event.card&&get.color(event.card)=='red';
			},
			content:function(){
				trigger.directHit=true;
			}
		},
		mingfu:{
			enable:'phaseUse',
			usable:1,
			filter:function(event,player){
				return player.num('he',{suit:'club'})>0;
			},
			position:'he',
			filterCard:{suit:'club'},
			discard:false,
			prepare:'throw',
			filterTarget:function(card,player,target){
				return lib.filter.targetEnabled({name:'guiyoujie'},player,target);
			},
			check:function(card){
				if(card.name=='du') return 20;
				return Math.max(7-ai.get.value(card),7-ai.get.useful(card));
			},
			content:function(){
				target.addJudge('guiyoujie',cards);
			},
			ai:{
				result:{
					target:function(player,target){
						return ai.get.effect(target,{name:'guiyoujie'},player,target);
					}
				},
				order:8,
			}
		},
        mufeng_old:{
            init:function(player){
                player.storage.mufeng=0;
            },
            group:['mufeng_gain','mufeng_lose'],
            mark:true,
			intro:{
				content:function(storage){
					if(storage>0){
						return '防御距离+'+storage;
					}
					else if(storage<0){
						return '防御距离'+storage;
					}
					else{
						return '无距离变化';
					}
				}
			},
            subSkill:{
                lose:{
                    trigger:{global:'dieAfter'},
                    forced:true,
                    filter:function(event,player){
                        return player.storage.mufeng>game.players.length/2;
                    },
                    content:function(){
                        player.storage.mufeng=0;
                        player.updateMarks();
                    }
                },
                gain:{
                    trigger:{player:'loseEnd'},
                    forced:true,
                    filter:function(event,player){
                        return _status.currentPhase!=player;
                    },
                    content:function(){
                        player.storage.mufeng++;
                        if(player.storage.mufeng>game.players.length/2){
                            player.storage.mufeng=0;
                        }
                        player.updateMarks();
                    }
                },
            },
            mod:{
				globalTo:function(from,to,distance){
					if(typeof to.storage.mufeng=='number'){
						return distance+to.storage.mufeng;
					}
				}
			}
        },
		mufeng:{
			trigger:{global:'phaseEnd'},
			filter:function(event,player){
				return !player.hasSkill('mufeng2')&&event.player!=player&&
				Math.min(5,event.player.num('h'))>player.num('h');
			},
			content:function(){
				player.draw(Math.min(5,trigger.player.num('h'))-player.num('h'));
				player.addTempSkill('mufeng2',{player:'phaseBegin'});
			},
		},
		mufeng2:{},
		jiying:{
			mod:{
				targetInRange:function(card){
					if(card.name=='sha') return true;
				}
			},
		},
		minjing:{
			trigger:{player:'damageBegin'},
			forced:true,
			filter:function(event,player){
				if(player.get('e','2')) return false;
				if(event.source&&event.source.num('s','unequip')) return;
				if(Math.random()>1/3) return false;
				return true;
			},
			content:function(){
				trigger.num--;
			},
			ai:{
				threaten:0.8
			}
		},
		touxi:{
			trigger:{global:'phaseEnd'},
			check:function(event,player){
				return ai.get.damageEffect(event.player,player,player,'thunder')>0;
			},
			filter:function(event,player){
				return event.player!=player&&!player.hasSkill('touxi2')&&event.player.isAlive();
			},
			logTarget:'player',
			content:function(){
				"step 0"
				player.judge(function(card){
					if(get.color(card)=='black') return 1;
					return -1;
				});
				"step 1"
				if(result.bool){
					trigger.player.damage('thunder');
					player.addSkill('touxi2');
					event.finish();
				}
				else{
					if(player.num('he')){
                        var att=ai.get.attitude(trigger.player,player);
						trigger.player.discardPlayerCard(player,'he',function(button){
                            if(att>0) return 0;
                            return ai.get.buttonValue(button);
                        });
					}
				}
			},
			ai:{
				expose:0.3,
				threaten:1.2
			}
		},
		touxi2:{
			trigger:{player:'phaseBegin'},
			forced:true,
			popup:false,
			content:function(){
				player.removeSkill('touxi2');
			}
		},
		nlianji:{
			audio:'lianji',
			enable:'phaseUse',
			usable:1,
			filterTarget:function(card,player,target){
				if(player==target) return false;
				return target.num('h')>0;
			},
			selectTarget:2,
			multitarget:true,
			multiline:true,
			filter:function(event,player){
				return player.num('h')>0;
			},
			prepare:'throw',
			discard:false,
			filterCard:true,
			check:function(card){
				return 6-ai.get.value(card);
			},
			content:function(){
				"step 0"
				if(targets[0].num('h')&&targets[1].num('h')){
					targets[0].chooseToCompare(targets[1]);
				}
				else{
					event.finish();
				}
				"step 1"
				if(result.bool){
					targets[0].gain(cards);
					targets[0].$gain2(cards);
					targets[1].damage(targets[0]);
				}
				else{
					targets[1].gain(cards);
					targets[1].$gain2(cards);
					targets[0].damage(targets[1]);
				}
			},
			ai:{
				expose:0.3,
				threaten:2,
				order:9,
				result:{
					target:-1
				}
			},
		},
		lianji2:{
			group:['lianji3','lianji4']
		},
		lianji3:{
			trigger:{player:'shaHit'},
			forced:true,
			popup:false,
			content:function(){
				player.storage.lianji2=true;
			}
		},
		lianji4:{
			trigger:{player:'shaAfter'},
			forced:true,
			popup:false,
			content:function(){
				if(!player.storage.lianji2){
					player.damage('thunder',player.storage.lianji);
				}
				delete player.storage.lianji;
				delete player.storage.lianji2;
				player.removeSkill('lianji2');
			}
		},
		yinmo:{},
		miedao:{
			group:['miedao1','miedao2'],
			ai:{
				threaten:1.4
			}
		},
		miedao1:{
			trigger:{player:'phaseDrawBegin'},
			forced:true,
			filter:function(event,player){
				return player.hp<player.maxHp;
			},
			content:function(){
				trigger.num+=player.maxHp-player.hp;
			}
		},
		miedao2:{
			trigger:{player:'phaseDiscardBegin'},
			forced:true,
			filter:function(event,player){
				return player.hp<player.maxHp;
			},
			content:function(){
				player.chooseToDiscard(player.maxHp-player.hp,'he',true);
			}
		},
		milesxiehun:{
			trigger:{player:'phaseEnd'},
			forced:true,
			content:function(){
				"step 0"
				event.num=0;
				event.targets=game.players.slice(0);
				event.targets.remove(player);
				for(var i=0;i<event.targets.length;i++){
					event.targets.sort(lib.sort.random);
				}
				event.targets.splice(Math.max(1,player.maxHp-player.hp));
				//event.targets.unshift(player);
				"step 1"
				if(event.num<event.targets.length){
					var target=event.targets[event.num];
					target.discard(target.get('he').randomGet());
					event.num++;
					event.redo();
				}
			},
		},
		liaochen:{
			trigger:{player:'phaseEnd'},
			forced:true,
			content:function(){
				"step 0"
				event.num=0;
				event.targets=game.players.slice(0);
				"step 1"
				if(event.num<event.targets.length){
					if(event.targets[event.num].num('he')){
						event.targets[event.num].chooseToDiscard(true,'he');
					}
					event.num++;
					event.redo();
				}
			}
		},
		aojian:{
			enable:'phaseUse',
			usable:1,
			filter:function(event,player){
				return player.hp<player.maxHp;
			},
			filterTarget:function(card,player,target){
				return player!=target&&get.distance(player,target,'attack')<=1;
			},
			selectTarget:function(){
				return ui.selected.cards.length;
			},
			selectCard:function(){
				var player=_status.currentPhase;
				return [1,Math.min(game.players.length-1,player.maxHp-player.hp)];
			},
			filterCard:true,
			check:function(card){
				if(ui.selected.cards.length==0){
					return 8-ai.get.value(card);
				}
				return 5-ai.get.value(card);
			},
			content:function(){
				"step 0"
				target.damage();
				"step 1"
				// target.draw();
			},
			ai:{
				order:9,
				result:{
					target:function(player,target){
						return ai.get.damageEffect(target,player,target);
					}
				},
				threaten:function(player,target){
					if(target.hp==1) return 2;
					if(target.hp==2) return 1.5;
					return 0.5;
				},
				maixie:true,
				effect:{
					target:function(card,player,target){
						if(get.tag(card,'damage')){
							if(target.hp==target.maxHp) return [0,1];
						}
						if(get.tag(card,'recover')&&player.hp>=player.maxHp-1) return [0,0];
					}
				}
			}
		},
		moyan:{
			enable:'phaseUse',
			usable:1,
			filter:function(event,player){
				return player.hp<player.maxHp&&player.num('h',{color:'red'})>0;
			},
			filterTarget:function(card,player,target){
				return player!=target;//&&get.distance(player,target,'attack')<=1;
			},
			selectTarget:function(){
				return ui.selected.cards.length;
			},
			selectCard:function(){
				var player=_status.currentPhase;
				return [1,Math.min(game.players.length-1,player.maxHp-player.hp)];
			},
			filterCard:function(card){
				return get.color(card)=='red';
			},
			check:function(card){
				if(ui.selected.cards.length==0){
					return 8-ai.get.value(card);
				}
				return 6-ai.get.value(card);
			},
			line:'fire',
			content:function(){
				"step 0"
				target.damage('fire');
				"step 1"
				// target.draw();
			},
			ai:{
				order:9,
				result:{
					target:function(player,target){
						return ai.get.damageEffect(target,player,target,'fire');
					}
				},
				threaten:function(player,target){
					if(target.hp==1) return 2;
					if(target.hp==2) return 1.5;
					return 0.5;
				},
				maixie:true,
				effect:{
					target:function(card,player,target){
						if(get.tag(card,'damage')){
							if(target.hp==target.maxHp) return [0,1];
						}
						if(get.tag(card,'recover')&&player.hp>=player.maxHp-1) return [0,0];
					}
				}
			}
		},
		shejie:{
			trigger:{player:'damageEnd'},
			priority:9,
			check:function(event,player){
				return ai.get.attitude(player,event.source)<0;
			},
			filter:function(event){
				return event&&event.source;
			},
			content:function(){
				trigger.source.addSkill('shejie2');
			},
			ai:{
				threaten:0.4
			}
		},
		shejie2:{
			unique:true,
			trigger:{player:'phaseBegin'},
			forced:true,
			priority:10,
			mod:{
				cardEnabled:function(){
					return false;
				},
				cardUsable:function(){
					return false;
				},
				cardRespondable:function(){
					return false;
				},
				cardSavable:function(){
					return false;
				}
			},
			content:function(){
				player.removeSkill('shejie2')
			},
		},
		guiyin:{
			trigger:{player:'phaseDiscardEnd'},
			frequent:true,
			filter:function(event,player){
				return event.cards&&event.cards.length>1
			},
			content:function(){
				player.draw(2);
			},
		},
		wangchen:{
			trigger:{player:'phaseDiscardEnd'},
			direct:true,
			filter:function(event,player){
				if(event.cards){
					for(var i=0;i<event.cards.length;i++){
						if(get.type(event.cards[i])=='basic') return true;
					}
				}
				return false;
			},
			content:function(){
				"step 0"
				player.chooseTarget(get.prompt('wangchen')).ai=function(target){
					return ai.get.attitude(player,target)*(target.isTurnedOver()?1:-1);
				}
				"step 1"
				if(result.bool){
					var target=result.targets[0]
					player.logSkill('wangchen',target);
					target.turnOver();
				}
			},
			ai:{
				expose:0.5,
				threaten:2,
			}
		},
		wangchen2:{
			trigger:{player:'phaseBefore'},
			forced:true,
			popup:false,
			filter:function(event,player){
				var prev=player.previous;
				if(prev.storage.wangchen==prev){
					return true;
				}
			},
			content:function(){
				player.previous.out();
			}
		},
		wangchen3:{
			trigger:{player:'dieBegin'},
			forced:true,
			popup:false,
			filter:function(event,player){
				return player.storage.wangchen&&player.storage.wangchen.isOut();
			},
			content:function(){
				player.storage.wangchen.out();
			}
		},
		yihua:{
			trigger:{target:'useCardToBefore'},
			popup:false,
			direct:true,
			filter:function(event,player){
				// return event.card&&get.color(event.card)=='red'&&event.player!=player;
				return event.targets.length==1&&event.player!=player&&player.num('h')>=2;
			},
			content:function(){
				"step 0"
				var next=player.chooseToDiscard('是否弃置两张手牌将'+get.translation(trigger.card)+'反弹？',2);
				next.ai=function(card){
					if(ai.get.effect(player,trigger.card)<0){
						if(card.name=='liuxinghuoyu') return 7-ai.get.value(card);
						return 5-ai.get.value(card);
					}
					return 0;
				}
				next.logSkill='yihua';
				"step 1"
				if(result.bool){
					// player.discard(result.cards);
					trigger.target=trigger.player;
					trigger.player=player;
					trigger.untrigger();
					trigger.trigger('useCardToBefore');
				}
				// "step 2"
				// if(result.bool){
				// 	trigger.target=result.targets[0];
				// 	trigger.untrigger;
				// 	trigger.trigger('shaBefore');
				// 	game.delay();
				// }
			},
			ai:{
				threaten:function(player,target){
					if(target.num('h')<=2){
						return 2;
					}
					return 2/(target.num('h')-1);
				}
			}
		},
		youyin:{
			trigger:{global:'discardAfter'},
			filter:function(event,player){
				if(event.player==player) return false;
				if(player.num('h')>=5) return false;
				for(var i=0;i<event.cards.length;i++){
					if(get.type(event.cards[i])!='basic'){
						return true;
					}
				}
				return false;
			},
			frequent:true,
			content:function(){
				"step 0"
				if(trigger.delay==false) game.delay();
				"step 1"
				player.draw();
			},
		},
		fushen:{
			trigger:{player:'phaseBefore'},
			check:function(){
				return false;
			},
			direct:true,
			filter:function(event,player){
				return !player.phaseSkipped;
			},
			content:function(){
				"step 0"
				player.chooseTarget(function(card,player,target){
					if(player==target) return false;
					return true;
				},get.prompt('fushen')).ai=function(){
					return -1;//1+Math.random();
				}
				"step 1"
				if(result.bool){
					var target=result.targets[0];
					event.target=target;
					target.storage.fushen=player;
					game.swapPlayer(target);
					// player.out();
					// player.lockOut=true;
					// trigger.untrigger();
					// trigger.finish();
					// target.phase();
					// target.addSkill('fushen2');
					trigger.untrigger();
					trigger.finish();
				}
				else{
					event.finish();
				}
				"step 2"
				player.out();
				player.lockOut=true;
				if(player.ai.shown<0.5){
					player.ai.shown=0.5;
				}
				// trigger.untrigger();
				// trigger.finish();
				// target.phase();
				event.target.addSkill('fushen2');
				event.target.storage.fushen2=event.target.ai.shown;
				event.target.phase();
			},
			ai:{
				threaten:1.5,
			}
		},
		fushen2:{
			trigger:{player:'phaseAfter'},
			forced:true,
			popup:false,
			content:function(){
				var source=player.storage.fushen;
				player.ai.shown=player.storage.fushen2;
				delete player.storage.fushen;
				delete player.storage.fushen2;
				if(source){
				source.lockOut=false;
				source.out();
				game.swapPlayer(source);
				source.loseHp();
				player.removeSkill('fushen2');}
				// source.skip('phase');
			}
		},
		anlianying:{
			trigger:{player:'loseEnd'},
			frequent:true,
			filter:function(event,player){
				if(player.num('h')) return false;
				for(var i=0;i<event.cards.length;i++){
					if(event.cards[i].original=='h') return true;
				}
				return false;
			},
			content:function(){
				player.draw(2);
			},
			ai:{
				effect:{
					target:function(card){
						if(card.name=='guohe'||card.name=='liuxinghuoyu') return 0.5;
					}
				},
				noh:true,
			}
		},
		miejing:{
			init:function(player){
				player.storage.miejing=false;
			},
			enable:'phaseUse',
			filter:function(event,player){
				//if(player.maxHp<=1) return false;
				return !player.storage.miejing
			},
			intro:{
				content:'limited'
			},
			mark:true,
			line:'thunder',
			filterTarget:function(card,player,target){
				return player!=target;
			},
			selectTarget:-1,
			content:function(){
				"step 0"
				if(target==targets[0]){
					var cards=player.get('hej');
					for(var i=0;i<cards.length;i++){
						if(get.color(cards[i])!='black'){
							cards.splice(i,1);i--;
						}
					}
					cards.sort(lib.sort.random);
					player.discard(cards);
					player.storage.miejing=true;
					player.unmarkSkill('miejing');
				}
				"step 1"
				target.damage('thunder');
			}
		},
		// zhanlu:{
		// 	enable:'phaseUse',
		// 	filterCard:function(card){
		// 		return get.suit(card)=='heart';
		// 	},
		// 	position:'he',
		// 	viewAs:{name:'taoyuan'},
		// 	prompt:'将一张红桃牌当作桃园结义使用',
		// 	check:function(card){return 6-ai.get.value(card)},
		// 	ai:{
		// 		threaten:1.2
		// 	}
		// },
		zhanlu:{
			enable:'phaseUse',
			filterCard:function(card){var suit=get.suit(card); return suit=='spade';},
			position:'he',
			usable:1,
			filter:function(event,player){
				return player.num('he',{suit:'spade'})>0;
			},
			check:function(card){
				return 10-ai.get.value(card)
			},
			filterTarget:function(card,player,target){
				if(target.hp>=target.maxHp) return false;
				return true;
			},
			selectTarget:[1,3],
			content:function(){
				target.recover();
			},
			ai:{
				order:10,
				result:{
					target:function(player,target){
						if(player==target&&player.num('h')>player.hp) return 20;
						return ai.get.recoverEffect(target,player,target);
					}
				},
				threaten:2
			}
		},
		huopu:{
			enable:'phaseUse',
			usable:1,
			position:'he',
			filterCard:function(card){
				return get.suit(card)=='heart';
			},
			viewAs:{name:'liuxinghuoyu'},
			viewAsFilter:function(player){
				if(!player.num('he',{suit:'heart'})) return false;
			},
			prompt:'将一张红桃手牌当作流星火羽使用',
			check:function(card){return 6-ai.get.value(card)},
			ai:{
				threaten:1.4,
				order:9,
			}
		},
		rexue:{
			trigger:{global:'phaseBegin'},
			direct:true,
			filter:function(event,player){
				return lib.filter.targetEnabled({name:'sha'},player,event.player)&&player.hasSha();
			},
			content:function(){
				"step 0"
				player.chooseToUse({name:'sha'},'热血：是否对'+get.translation(trigger.player)+'使用一张杀',trigger.player,-1).logSkill='rexue';
				"step 1"
				if(result.bool){
					player.draw();
				}
			}
		},
		shengshou:{
			enable:'phaseUse',
			filterCard:function(card){
				return get.color(card)=='black';
			},
			viewAs:{name:'caoyao'},
			prompt:'将一张黑色手牌当作草药使用',
			check:function(card){return 6-ai.get.value(card)},
			ai:{
				threaten:1.6
			}
		},
		huanjian:{
			enable:'phaseUse',
			filterCard:function(card){
				return get.color(card)=='black';
			},
			viewAs:{name:'bingpotong'},
			position:'he',
			filter:function(event,player){
				return player.num('h',{color:'black'})>0;
			},
			viewAsFilter:function(player){
				if(!player.num('he',{color:'black'})) return false;
			},
			prompt:'将一张黑色牌当作冰魄筒使用',
			check:function(card){return 5-ai.get.value(card)},
			ai:{
				threaten:1.1
			}
		},
		benlei:{
			enable:'phaseUse',
			viewAs:{name:'jingleishan',nature:'thunder'},
			filterCard:function(card,player){
				return true;
			},
			selectCard:3,
			position:'he',
			prompt:'将三张牌当作惊雷闪使用',
			check:function(card){
				return 4-ai.get.value(card);
			},
			group:'benlei2',
			ai:{
				basic:{
					order:10
				}
			}
		},
		benlei2:{
			trigger:{source:'damageAfter'},
			filter:function(event,player){
				return event.nature=='thunder'&&player.hp<player.maxHp;
			},
			forced:true,
			content:function(){
				player.recover();
			},
		},
		moyu:{
			trigger:{source:'dieAfter'},
			filter:function(event,player){
				return player.hp<player.maxHp;
			},
			frequent:true,
			content:function(){
				player.recover(player.maxHp-player.hp);
			},
			threaten:1.2
		},
		susheng:{
			trigger:{global:'dieBefore'},
			direct:true,
			check:function(event,player){
				return player.attitudeTo(event.player)>3;
			},
			filter:function(event,player){
				return player.num('h')>0&&!player.hasSkill('susheng2');
			},
			content:function(){
				"step 0"
				var att=ai.get.attitude(player,trigger.player);
				var nh=player.num('h');
				var next=player.chooseToDiscard(get.prompt('susheng',trigger.player));
				next.logSkill=['susheng',trigger.player];
				next.ai=function(card){
					if(att>3||(att>1&&nh>2)){
						return ai.get.unuseful2(card);
					}
					return 0;
				};
				"step 1"
				if(result.bool){
					// player.chooseToDiscard('h',true);
					trigger.untrigger();
					trigger.finish();
					trigger.player.hp=1;
					if(trigger.player.maxHp<1) trigger.player.maxHp=1;
					trigger.player.update();
					player.addTempSkill('susheng2','phaseAfter');
				}

			},
			ai:{
				threaten:2
			}
		},
		susheng2:{},
		kunlunjing:{
			unique:true,
			group:['kunlunjing1','kunlunjing2'],
			video:function(player,data){
				if(data){
					for(var i in data){
						var current=game.playerMap[i];
						current.node.handcards1.innerHTML='';
						current.node.handcards2.innerHTML='';
						current.node.equips.innerHTML='';
						current.node.judges.innerHTML='';
						current.directgain(get.infoCards(data[i].h));
						var es=get.infoCards(data[i].e);
						for(var j=0;j<es.length;j++){
							current.$equip(es[j]);
						}
						var js=get.infoCards(data[i].j);
						for(var j=0;j<js.length;j++){
							current.node.judges.appendChild(js[j]);
						}
					}
					ui.window.classList.remove('zoomout3');
					ui.window.classList.add('zoomin3');
					document.body.appendChild(ui.window);
					setTimeout(function(){
						ui.window.show();
						ui.window.classList.remove('zoomin3');
						setTimeout(function(){
							ui.window.style.transition='';
						},500);
					},100);
				}
				else{
					ui.window.style.transition='all 0.5s';
					ui.window.classList.add('zoomout3');
					ui.window.delete();
					ui.window.hide();
				}
			},
		},
		kunlunjing1:{
			trigger:{player:'phaseBegin'},
			priority:10,
			filter:function(event,player){
				if(!player.storage.kunlunjing) return false;
				return player.hp<player.storage.kunlunjing2;
			},
			onremove:['kunlunjing','kunlunjing2'],
			check:function(event,player){
				var storage=player.storage.kunlunjing;
				var num=0;
				for(var i=0;i<storage.length;i++){
					if(game.players.contains(storage[i].player)){
						var att=ai.get.attitude(player,storage[i].player);
						var num2=storage[i].value-storage[i].player.num('he')+storage[i].player.num('j');
						if(att>0){
							num+=num2;
						}
						else if(att<0){
							num-=num2;
						}
					}
				}
				return num>Math.min(2,game.players.length/2);
			},
			content:function(){
				"step 0"
				game.delay(0.5);
				"step 1"
				ui.window.style.transition='all 0.5s';
				ui.window.classList.add('zoomout3');
				ui.window.delete();
				ui.window.hide();
				game.delay(0,500);
				game.addVideo('skill',event.player,'kunlunjing');
				"step 2"
				var storage=event.player.storage.kunlunjing;
				var player,frag;
				var i,j;
				for(i=0;i<storage.length;i++){
					if(game.players.contains(storage[i].player)){
						player=storage[i].player;
						while(player.node.handcards1.childNodes.length)
						ui.discardPile.appendChild(player.node.handcards1.firstChild);

						while(player.node.handcards2.childNodes.length)
						ui.discardPile.appendChild(player.node.handcards2.firstChild);

						while(player.node.judges.childNodes.length)
						ui.discardPile.appendChild(player.node.judges.firstChild);

						while(player.node.equips.childNodes.length)
						ui.discardPile.appendChild(player.node.equips.firstChild);
					}
				}
				for(i=0;i<storage.length;i++){
					if(game.players.contains(storage[i].player)){
						player=storage[i].player;
						for(j=0;j<storage[i].handcards1.length;j++){
							if(storage[i].handcards1[j].parentNode==ui.discardPile||
							storage[i].handcards1[j].parentNode==ui.cardPile){
								player.node.handcards1.appendChild(storage[i].handcards1[j]);
							}
							else{
								player.node.handcards1.appendChild(game.createCard(storage[i].handcards1[j]));
							}
						}
						for(j=0;j<storage[i].handcards2.length;j++){
							if(storage[i].handcards2[j].parentNode==ui.discardPile||
							storage[i].handcards2[j].parentNode==ui.cardPile){
								player.node.handcards2.appendChild(storage[i].handcards2[j]);
							}
							else{
								player.node.handcards2.appendChild(game.createCard(storage[i].handcards2[j]));
							}
						}
						for(j=0;j<storage[i].equips.length;j++){
							if(storage[i].equips[j].parentNode==ui.discardPile||
							storage[i].equips[j].parentNode==ui.cardPile){
								storage[i].equips[j].style.transform='';
								player.$equip(storage[i].equips[j]);
							}
							else{
								player.$equip(game.createCard(storage[i].equips[j]));
							}
						}
						for(j=0;j<storage[i].judges.length;j++){
							if(storage[i].judges[j].parentNode==ui.discardPile||
							storage[i].judges[j].parentNode==ui.cardPile){
								storage[i].judges[j].style.transform='';
								storage[i].judges[j].viewAs=storage[i].viewAs[j];
								if(storage[i].judges[j].viewAs&&storage[i].judges[j].viewAs!=storage[i].judges[j].name&&storage[i].judges[j].classList.contains('fullskin')){
	                                storage[i].judges[j].classList.add('fakejudge');
	                                storage[i].judges[j].node.background.innerHTML=lib.translate[storage[i].judges[j].viewAs+'_bg']||get.translation(storage[i].judges[j].viewAs)[0]
	                            }
								player.node.judges.appendChild(storage[i].judges[j]);
							}
						}
						player.update();
					}
				}
				game.delay(0,100);
				ui.window.classList.remove('zoomout3');
				ui.window.classList.add('zoomin3');
				document.body.appendChild(ui.window);
				var data={};
				for(var i=0;i<game.players.length;i++){
					data[game.players[i].dataset.position]={
						h:get.cardsInfo(game.players[i].get('h')),
						e:get.cardsInfo(game.players[i].get('e')),
						j:get.cardsInfo(game.players[i].get('j'))
					}
				}
				game.addVideo('skill',event.player,['kunlunjing',data]);
				"step 3"
				ui.window.show();
				ui.window.classList.remove('zoomin3');
				setTimeout(function(){
					ui.window.style.transition='';
					game.resume();
				},500);
				game.pause();
				'step 4'
				ui.updatehl();
			}
		},
		kunlunjing2:{
			trigger:{player:'phaseAfter'},
			forced:true,
			popup:false,
			silent:true,
			content:function(){
				var handcards1,handcards2,judges,equips,viewAs,i,j;
				player.storage.kunlunjing=[];
				player.storage.kunlunjing2=player.hp;

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

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

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

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

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

					player.storage.kunlunjing.push({
						player:game.players[i],
						handcards1:handcards1,
						handcards2:handcards2,
						judges:judges,
						equips:equips,
						viewAs:viewAs,
						value:handcards1.length+handcards2.length+equips.length-judges.length
					});
				}
			}
		},
		oldliaoyuan:{
			enable:'phaseUse',
			usable:1,
			filter:function(event,player){
				return player.num('h')>0
			},
			filterTarget:function(card,player,target){
				return player!=target
			},
			filterCard:function(card,player){
				if(ui.selected.cards.length){
					return get.suit(card)==get.suit(ui.selected.cards[0]);
				}
				var cards=player.get('h');
				for(var i=0;i<cards.length;i++){
					if(card!=cards[i]){
						if(get.suit(card)==get.suit(cards[i])) return true;
					}
				}
				return false;
			},
			prepare:'throw',
			// selectTarget:[1,2],
			selectCard:[2,2],
			check:function(card){return 6-ai.get.useful(card)},
			prompt:'弃置两张相同花色的手牌，选择一名角色弃置其一张牌，并视为对其使用一张火杀',
			content:function(){
				"step 0"
				if(target.num('he')){
					player.discardPlayerCard(target,'he');
				}
				"step 1"
				player.useCard({name:'sha',nature:'fire'},target,false,'oldliaoyuan').animate=false;
			},
			ai:{
				order:3,
				result:{
					target:function(player,target){
						return ai.get.effect(target,{name:'sha',nature:'fire'},player,target)-1;
					}
				},
				expose:0.2
			}
		},
		oldliaoyuan2:{
			enable:'phaseUse',
			usable:1,
			filter:function(event,player){
				return player.num('h')>0
			},
			filterTarget:function(card,player,target){
				return player!=target
			},
			filterCard:function(card,player){
				if(ui.selected.cards.length){
					return get.suit(card)==get.suit(ui.selected.cards[0]);
				}
				var cards=player.get('h');
				for(var i=0;i<cards.length;i++){
					if(card!=cards[i]){
						if(get.suit(card)==get.suit(cards[i])) return true;
					}
				}
				return false;
			},
			delay:false,
			discard:false,
			selectCard:[2,2],
			check:function(card){return 7-ai.get.value(card)},
			content:function(){
				"step 0"
				player.useCard({name:'sha'},[cards[0]],target,false,'liaoyuan');
				"step 1"
				player.useCard({name:'sha'},[cards[1]],target,false,'liaoyuan');
			},
			ai:{
				order:6,
				result:{
					target:function(player,target){
						return ai.get.effect(target,{name:'sha'},player,target)*2;
					}
				},
				expose:0.2
			}
		},
		shehun:{
			enable:'phaseUse',
			usable:1,
			filter:function(event,player){
				return player.num('h')>0;
			},
			filterTarget:function(card,player,target){
				return player!=target&&target.num('he')>0;
			},
			filterCard:function(card){
				var suit=get.suit(card);
				for(var i=0;i<ui.selected.cards.length;i++){
					if(get.suit(ui.selected.cards[i])==suit) return false;
				}
				return true;
			},
			selectCard:[1,4],
			check:function(card){
				return 7-ai.get.value(card)
			},
			content:function(){
				"step 0"
				var suits=[];
				event.suits=suits;
				for(var i=0;i<cards.length;i++){
					suits.push(get.suit(cards[i]));
				}
				var hs=target.get('he');
				var hss={
					club:[],
					diamond:[],
					spade:[],
					heart:[]
				}
				var choice=[];
				for(var i=0;i<hs.length;i++){
					var suity=get.suit(hs[i]);
					if(hss[suity]){
						hss[suity].push(hs[i]);
					}
				}
				for(var i in hss){
					if(!suits.contains(i)){
						choice=choice.concat(hss[i]);
						delete hss[i];
					}
				}
				if(choice.length<cards.length){
					choice.length=0;
				}
				target.chooseToDiscard(cards.length,true,'he').ai=function(card){
					var num=choice.contains(card)?20:0;
					return num-ai.get.value(card);
				}
				"step 1"
				var damage=false;
				for(var i=0;i<result.cards.length;i++){
					if(event.suits.contains(get.suit(result.cards[i]))){
						damage=true;break;
					}
				}
				if(damage){
					target.damage();
				}
			},
			ai:{
				order:6,
				result:{
					target:function(player,target){
						var eff=ai.get.damageEffect(target,player);
						var num=target.num('he');
						var length=ui.selected.cards.length;
						if(num==length) return -2+eff;
						if(num>length) return -1.5+eff;
						return -1+eff;
					}
				},
				expose:0.2
			}
		},
		liaoyuan:{
			trigger:{player:'shaBegin'},
			direct:true,
			filter:function(event,player){
				if(get.itemtype(event.cards)!='cards') return false;
				return player.num('he',{suit:get.suit(event.cards)})>0;
			},
			content:function(){
				"step 0"
				player.storage.liaoyuan=0;
				event.num=0;
				event.cards=[];
				"step 1"
				var suit=get.suit(trigger.cards);
				event.suit=suit;
				player.chooseCard('he',get.prompt('liaoyuan'),function(card,player){
					return get.suit(card)==suit&&lib.filter.cardDiscardable(card,player);
				}).ai=function(card){
					if(ai.get.attitude(player,trigger.target)>=0) return 0;
					if(ai.get.effect(trigger.target,{name:'sha'},player,player)>0){
						return 7-ai.get.value(card);
					}
					return 0;
				}
				"step 2"
				if(result.bool){
					if(event.num==0){
						player.logSkill('liaoyuan');
					}
					player.discard(result.cards);
					event.num++;
					if(player.num('he',{suit:event.suit})>1){
						event.goto(1);
					}
				}
				"step 3"
				if(event.num){
					trigger.target.chooseToRespond({name:'shan'}).ai=ai.get.unuseful2;
				}
				else{
					event.finish();
				}
				"step 4"
				if(result.bool){
					event.num--;
					event.goto(3);
				}
				else{
					trigger.untrigger();
					trigger.directHit=true;
					player.storage.liaoyuan=event.num;
				}
			},
			group:['liaoyuan2','liaoyuan3']
		},
		liaoyuan2:{
			trigger:{source:'damageBegin'},
			forced:true,
			popup:false,
			filter:function(event,player){
				return event.card&&event.card.name=='sha'&&player.storage.liaoyuan>0&&event.parent.name!='_lianhuan'&&event.parent.name!='_lianhuan2';
			},
			content:function(){
				trigger.num+=player.storage.liaoyuan;
				player.storage.liaoyuan=0;
			}
		},
		liaoyuan3:{
			trigger:{player:'shaEnd'},
			forced:true,
			popup:false,
			silent:true,
			content:function(){
				player.storage.liaoyuan=0;
			}
		},
		dunxing:{
			inherit:'tuoqiao'
		},
		qiaoxie:{
			group:['qiaoxie2','qiaoxie3'],
			ai:{
				effect:{
					target:function(card,player,target,current){
						if(get.type(card)=='equip') return [1,3];
					}
				},
				noe:true,
			}
		},
		qiaoxie2:{
			trigger:{player:'equipEnd'},
			frequent: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(){
				//var num=0;
				//for(var i=0;i<trigger.cards.length;i++){
				//	if(trigger.cards[i].original=='e') num++;
				//}
				player.draw();
			},
			//effect:{
			//	target:function(card,player,target,current){
			//		if(get.type(card)=='equip') return [1,1];
			//	}
			//}
		},
		duanxing:{
			trigger:{player:'equipEnd'},
			direct:true,
			filter:function(event){
				return lib.inpile.contains(event.card.name);
			},
			content:function(){
				"step 0"
				player.chooseTarget(get.prompt('duanxing'),function(card,player,target){
					return lib.filter.targetEnabled({name:'sha'},player,target);
				}).ai=function(target){
					return ai.get.effect(target,{name:'sha'},player);
				}
				"step 1"
				if(result.bool){
					player.logSkill('duanxing');
					player.useCard({name:'sha'},result.targets,false);
				}
			},
			ai:{
				expose:0.2
			}
		},
		qiaoxie3:{
			trigger:{player:['loseEnd']},
			direct:true,
			filter:function(event,player){
				if(player.equiping) return false;
				for(var i=0;i<event.cards.length;i++){
					if(event.cards[i].original=='e') return true;
				}
				return false;
			},
			content:function(){
				"step 0"
				game.delay(0.5);
				player.chooseTarget([1,1],'请选择巧械的目标',function(card,player,target){
					if(player==target) return false;
					return target.num('he')>0;
				}).ai=function(target){
					return -ai.get.attitude(player,target);
				};
				"step 1"
				if(result.bool){
					player.logSkill('qiaoxie3',result.targets);
					player.discardPlayerCard(result.targets[0],'he',true);
				}
				else{
					event.finish();
				}
			},
		},
		qiaoxie4:{
			trigger:{player:['loseEnd']},
			frequent:true,
			filter:function(event,player){
				if(typeof lib.cardType.hslingjian!='number') return false;
				if(!player.equiping) return false;
				for(var i=0;i<event.cards.length;i++){
					if(event.cards[i].original=='e') return true;
				}
				return false;
			},
			content:function(){
				player.gain(game.createCard(get.typeCard('hslingjian').randomGet()),'gain2');
			}
		},
		meihuo:{
			trigger:{player:['loseEnd']},
			direct:true,
			filter:function(event,player){
				if(player.equiping) return false;
				if(player.num('e')) return false;
				for(var i=0;i<event.cards.length;i++){
					if(event.cards[i].original=='e') return true;
				}
				return false;
			},
			content:function(){
				"step 0"
				player.chooseTarget([1,1],get.prompt('meihuo'),function(card,player,target){
					if(player==target) return false;
					return target.num('he')>0;
				}).ai=function(target){
					var att=ai.get.attitude(player,target);
					if(att<=0){
						return 1-att+(target.num('e')?2:0);
					}
					return 0;
				};
				"step 1"
				if(result.bool){
					event.target=result.targets[0];
					player.logSkill('meihuo',event.target);
					player.choosePlayerCard(event.target,'he',true).ai=function(button){
						var card=button.link;
						if(get.position(card)=='e') return ai.get.equipValue(card);
						return 5;
					};
				}
				"step 2"
				if(result.bool){
					if(get.position(result.buttons[0].link)=='e'){
						player.equip(result.buttons[0].link);
					}
					else{
						player.gain(result.buttons[0].link,event.target);
					}
					event.target.$give(1,player);
					game.delay();
				}
			},
		},
		yuhuo:{
			enable:'chooseToUse',
			filter:function(event,player){
				if(event.type!='dying') return false;
				if(player!=_status.dying) return false;
				if(player.storage.yuhuo) return false;
				return true;
			},
			content:function(){
				player.maxHp--;
				player.hp=player.maxHp;
				player.discard(player.get('hej'));
				if(player.isLinked()) player.link();
				if(player.isTurnedOver()) player.turnOver();
				player.storage.yuhuo=true;
				// player.addSkill('guanhong');
				// player.addSkill('yishan2');
				player.update();
			},
			ai:{
				result:{
					player:10
				},
				threaten:function(player,target){
					if(!target.storage.yuhuo) return 0.8;
				}
			},
			init:function(player){
				player.storage.yuhuo=false;
			},
			intro:{
				content:'limited'
			}
		},
		yishan:{
			group:'yishan2',
			trigger:{player:'damageEnd'},
			filter:function(event,player){
				var content=player.storage.yishan;
				for(var i=0;i<content.length;i++){
					if(get.owner(content[i])!=player&&get.position(content[i])!='s'){
						return true;
					}
				}
				return false;
			},
			init:function(player){
				player.storage.yishan=[];
				game.addVideo('storage',player,['yishan',get.cardsInfo(player.storage.yishan),'cards']);
			},
			mark:true,
			content:function(){
				for(var i=0;i<player.storage.yishan.length;i++){
					if(get.owner(player.storage.yishan[i])==player||get.position(player.storage.yishan[i])=='s'){
						player.storage.yishan.splice(i,1);
						i--;
					}
				}
				var cards=player.storage.yishan.splice(0,2);
				player.gain(cards,'log');
				player.$gain2(cards);
			},
			ai:{
				maixie:true,
				effect:{
					target:function(card,player,target){
						if(get.tag(card,'damage')){
							if(player.hasSkill('jueqing')) return [1,-2];
							if(target.storage.yishan.length==0) return 1.5;
							if(target.storage.yishan[0]=='tao'||target.storage.yishan[1]=='tao'){
								return [0,2];
							}
							return [1,1];
						}
					}
				}
			},
			intro:{
				nocount:true,
				onunmark:function(content,player){
					player.storage.yishan.length=0;
				},
				mark:function(dialog,content,player){
					dialog.add('<div class="text center">最近失去的牌</div>');
					var cards=[];
					for(var i=0;i<content.length;i++){
						if(get.owner(content[i])!=player&&get.position(content[i])!='s'){
							cards.push(content[i]);
							if(cards.length>=4) break;
						}
					}
					if(cards.length){
						dialog.add(cards);
					}
					else{
						dialog.add('（无）');
					}
				},
				content:function(content,player){
					var str='最近失去的牌：';
					var cards=[];
					for(var i=0;i<content.length;i++){
						if(get.owner(content[i])!=player&&get.position(content[i])!='s'){
							cards.push(content[i]);
							if(cards.length>=4) break;
						}
					}
					if(cards.length){
						str+=get.translation(cards);
					}
					else{
						str+='无';
					}
					return str;
				}
			}
		},
		yishan2:{
			trigger:{player:'loseEnd'},
			forced:true,
			popup:false,
			silent:true,
			content:function(){
				for(var i=0;i<trigger.cards.length;i++){
					player.storage.yishan.unshift(trigger.cards[i]);
				}
				game.addVideo('storage',player,['yishan',get.cardsInfo(player.storage.yishan),'cards']);
			}
		},
		guanhu:{
			trigger:{source:'damageEnd'},
			direct:true,
			filter:function(event){
				return event.card&&event.card.name=='sha'&&event.player.num('he');
			},
			check:function(event,player){
				return ai.get.attitude(player,event.player)<0;
			},
			content:function(){
				player.discardPlayerCard(trigger.player).logSkill=['guanhu',trigger.player];
			},
			ai:{
				expose:0.2
			}
		},
		chuanyang:{
			trigger:{player:'shaBegin'},
			check:function(event,player){
				return ai.get.attitude(player,event.player)<0;
			},
			filter:function(event,player){
				// if(event.card&&get.color(event.card)=='red') return true;
				// return false;
				return get.distance(event.target,player,'attack')>1;
			},
			content:function(){
				trigger.directHit=true;
			}
		},
		poxing:{
			trigger:{source:'damageBegin'},
			filter:function(trigger,player){
				return trigger.player.hp>player.hp;
			},
			forced:true,
			content:function(){
				trigger.num++;
			}
		},
		luomu:{
			trigger:{source:'damageEnd'},
			forced:true,
			filter:function(event,player){
				return event.player.num('hej');
			},
			content:function(){
				trigger.player.discard(trigger.player.get('hej').randomGet());
			}
		},
		huanhun:{
			trigger:{global:'dying'},
			priority:6,
			filter:function(event,player){
				return event.player.hp<=0&&player.num('he')>0;
			},
			direct:true,
			content:function(){
				"step 0"
				var next=player.chooseToDiscard('he',get.prompt('huanhun'),function(card){
					return get.color(card)=='red';
				});
				next.logSkill=['huanhun',trigger.player];
				next.ai=function(card){
					if(card.name=='tao') return 0;
					if(ai.get.attitude(player,trigger.player)>0){
						return 8-ai.get.value(card);
					}
					return 0;
				};
				"step 1"
				if(result.bool){
					trigger.player.judge(function(card){
						return get.color(card)=='red'?1:-1;
					});
				}
				else{
					event.finish();
				}
				"step 2"
				if(result.bool){
					trigger.player.recover();
				}
			},
			ai:{
				threaten:1.6,
				expose:0.2
			}
		},
		huanhun_old:{
			enable:'phaseUse',
			forbid:['versus'],
			filter:function(){
				return game.dead.length>0
			},
			usable:1,
			filterCard:function(card){
				return get.suit(card)=='heart';
			},
			check:function(card){
				return 10-ai.get.value(card);
			},
			direct:true,
			content:function(){
				"step 0"
				var list=[];
				for(var i=0;i<game.dead.length;i++){
					list.push(game.dead[i].name);
				}
				player.chooseButton(ui.create.dialog([list,'character']),function(button){
					for(var i=0;i<game.dead.length&&game.dead[i].name!=button.link;i++);
					return ai.get.attitude(_status.event.player,game.dead[i])-2;
				},true);
				"step 1"
				if(result.bool){
					for(var i=0;i<game.dead.length&&game.dead[i].name!=result.buttons[0].link;i++);
					var dead=game.dead[i];
					dead.hp=1;
					dead.revive();
					event.dead=dead;
					player.logSkill('huanhun',dead);
				}
				else{
					event.finish();
				}
				"step 2"
				if(event.dead) event.dead.draw(2);
			},
			ai:{
				order:10,
				result:{
					player:function(player){
						for(var i=0;i<game.dead.length;i++){
							if(ai.get.attitude(player,game.dead[i])>2) return 3;
						}
						return 0;
					}
				},
				threaten:2,
			}
		},
		yinyue:{
			trigger:{global:'recoverAfter'},
			check:function(event,player){
				return ai.get.attitude(player,event.player)>0;
			},
			logTarget:'player',
			content:function(){
				"step 0"
				if(trigger.player!=player&&trigger.player.num('h')>=player.num('h')){
					game.asyncDraw([trigger.player,player]);
				}
				else{
					trigger.player.draw();
					event.finish();
				}
				"step 1"
				game.delay();
			},
			ai:{
				expose:0.2
			}
		},
		daofa:{
			trigger:{global:'damageAfter'},
			check:function(event,player){
				return event.source&&ai.get.attitude(player,event.source)<0;
			},
			filter:function(event,player){
				return event.source&&event.source!=player&&event.source.num('he');
			},
			logTarget:'source',
			content:function(){
				trigger.source.chooseToDiscard('he',true);
			},
			ai:{
				expose:0.2,
				threaten:1.5
			}
		},
		daixing:{
			group:'daixing2',
			trigger:{player:'phaseEnd'},
			direct:true,
			content:function(){
				"step 0"
				var next=player.chooseToDiscard('请选择发动代形的卡牌','he',[1,player.num('he')]);
				next.logSkill='daixing';
				next.ai=function(card){
					if(ui.selected.cards.length>=2) return 0;
					if(ui.selected.cards.length==1){
						if(player.num('h')>player.hp){
							return 3-ai.get.value(card);
						}
						return 0;
					}
					return 6-ai.get.value(card);
				};
				"step 1"
				if(result.bool){
					player.changeHujia(result.cards.length);
					player.storage.daixing=result.cards.length;
				}
			},
			ai:{
				effect:{
					target:function(card,player,target){
						if(get.tag(card,'damage')){
							if(player.hasSkill('jueqing')) return;
							if(target.storage.daixing>1) return 0.1;
							if(target.storage.daixing==1) return 0.5;
						}
						return 1.5;
					}
				}
			},
			intro:{
				content:'mark'
			}
		},
		daixing2:{
			trigger:{player:'phaseBegin'},
			forced:true,
			popup:false,
			silent:true,
			content:function(){
				if(player.storage.daixing){
					player.changeHujia(-player.storage.daixing);
					player.storage.daixing=0;
				}
			}
		},
		swd_wuxie:{
			mod:{
				targetEnabled:function(card,player,target){
					if(get.type(card)=='delay'&&player!=target){
						return false;
					}
				}
			}
		},
		qingcheng:{
			trigger:{player:'phaseEnd'},
			frequent:true,
			content:function(){
				"step 0"
				if(event.cards==undefined) event.cards=[];
				player.judge(function(card){
					if(get.color(card)=='red') return 1.5;
					return -1.5;
				},ui.special);
				"step 1"
				if(result.judge>0){
					event.cards.push(result.card);
					if(event.cards.length==3){
						player.gain(event.cards);
						if(event.cards.length){
							player.$draw(event.cards);
						}
						event.finish();
					}
					else if(lib.config.autoskilllist.contains('qingcheng')){
						player.chooseBool('是否再次发动？');
					}
					else{
						event._result={bool:true};
					}
				}
				else{
					player.gain(event.cards);
					if(event.cards.length){
						player.$draw(event.cards);
					}
					event.finish();
				}
				"step 2"
				if(result.bool){
					event.goto(0);
				}
				else{
					player.gain(event.cards);
					if(event.cards.length){
						player.$draw(event.cards);
					}
				}
			},
			ai:{
				threaten:1.4
			}
		},
		lingxin:{
			trigger:{player:'phaseEnd'},
			frequent:true,
			content:function(){
				"step 0"
				event.cards=get.cards(3);
				player.showCards(event.cards);
				"step 1"
				for(var i=0;i<cards.length;i++){
					if(get.suit(event.cards[i])!='heart'){
						ui.discardPile.appendChild(cards[i]);
						event.cards.splice(i--,1);
					}
				}
				if(event.cards.length==0){
					event.finish();
				}
				else{
					game.delay(0,1000);
					player.$gain2(event.cards);
				}
				"step 2"
				player.gain(event.cards,'log');
			},
			ai:{
				result:{
					target:2
				}
			}
		},
		lingwu:{
			trigger:{player:'phaseAfter'},
			frequent:true,
			filter:function(event,player){
				return get.cardCount(true,player)>=player.hp&&event.parent.name!='lingwu';
			},
			content:function(){
				player.phase();
			},
			ai:{
				order:-10,
				result:{
					target:2
				},
				threaten:1.5
			}
		},
		xianjiang_old:{
			enable:'phaseUse',
			position:'he',
			usable:1,
			filterCard:function(card,player){
				if(player.storage.xianjiang&&player.storage.xianjiang.contains(card)) return false;
				return get.type(card)=='equip';
			},
			init:function(player){
				player.storage.xianjiang=[];
			},
			check:function(card){
				return 10-ai.get.value(card);
			},
			prompt:'将一张装备牌永久转化为任意一张装备牌',
			content:function(){
				"step 0"
				var list=[];
				var suit=get.suit(cards[0]);
				var number=get.number(cards[0]);
				for(var i in lib.card){
					if(lib.card[i].mode&&lib.card[i].mode.contains(lib.config.mode)==false) continue;
					if(lib.card[i].type=='equip'&&cards[0].name!=i){
						if(ai.get.equipValue({name:i})<10) list.push([suit,number,i]);
					}
				}
				var dialog=ui.create.dialog([list,'vcard']);
				player.chooseButton(dialog,true,function(button){
					return ai.get.value({name:button.link[2]},player);
				});
				"step 1"
				cards[0].init(result.buttons[0].link);
				player.gain(cards[0]);
				player.$gain(cards[0]);
				game.delay();
				player.storage.xianjiang.add(cards[0]);
			},
			ai:{
				order:9,
				result:{
					player:1
				},
				threaten:2,
			}
		},
		xianjiang2:{
			trigger:{player:'phaseUseBegin'},
			forced:true,
			popup:false,
			filter:function(event,player){
				return player.hasSkill('xianjiang');
			},
			content:function(){
				player.storage.xianjiang=[];
			}
		},
		xianjiang:{
			enable:'phaseUse',
			filterCard:function(card){
				return get.type(card,'trick')=='trick';
			},
			usable:1,
			filter:function(event,player){
				if(player.num('h',{type:'trick'})) return true;
				if(player.num('h',{type:'delay'})) return true;
				return false;
			},
			selectCard:1,
			check:function(card){
				return 8-ai.get.value(card);
			},
			content:function(){
				var card=game.createCard(get.inpile('equip').randomGet());
				player.equip(card);
				player.$gain2(card);
				game.delay();
			},
			ai:{
				result:{
					player:1
				},
				order:9
			}
		},
		shengong:{
			trigger:{player:'chooseToRespondBegin'},
			filter:function(event,player){
				if(event.responded) return false;
				if(!player.num('he')) return false;
				if(event.filterCard({name:'shan'})){
					for(var i=0;i<game.players.length;i++){
						if(game.players[i]!=player&&game.players[i].get('e','2')) return true;
					}
				}
				if(event.filterCard({name:'sha'})){
					for(var i=0;i<game.players.length;i++){
						if(game.players[i]!=player&&game.players[i].get('e','1')) return true;
					}
				}
				return false;
			},
			direct:true,
			content:function(){
				"step 0"
				var list=[];
				if(trigger.filterCard({name:'shan'})){
					for(var i=0;i<game.players.length;i++){
						if(game.players[i]!=player&&game.players[i].get('e','2')) list.push(game.players[i].get('e','2'));
					}
				}
				if(trigger.filterCard({name:'sha'})){
					for(var i=0;i<game.players.length;i++){
						if(game.players[i]!=player&&game.players[i].get('e','1')) list.push(game.players[i].get('e','1'));
					}
				}
				var dialog=ui.create.dialog('神工',list);
				for(var i=0;i<dialog.buttons.length;i++){
					dialog.buttons[i].querySelector('.info').innerHTML=get.translation(get.owner(dialog.buttons[i].link));
				}
				player.chooseButton(dialog,function(button){
					var player=get.owner(button.link);
					if(get.subtype(button.link)=='equip2'&&player.num('shan')==0){
						return 11-ai.get.attitude(_status.event.player,player);
					}
					if(get.subtype(button.link)=='equip1'&&player.num('sha')==0){
						return 11-ai.get.attitude(_status.event.player,player);
					}
					return 5-ai.get.attitude(_status.event.player,player);
				});
				"step 1"
				if(result.bool){
					trigger.untrigger();
					trigger.responded=true;
					trigger.result={bool:true,card:{}};
					if(get.subtype(result.buttons[0].link)=='equip1') trigger.result.card.name='sha';
					else trigger.result.card.name='shan';
					var target=get.owner(result.buttons[0].link);
					target.discard(result.buttons[0].link);
					target.draw();
					if(player.num('he')) player.chooseToDiscard(true,'he');
					player.logSkill('shengong',target);
				}
			},
			ai:{
				effect:{
					target:function(card,player,target,current){
						if(target.num('he')<=1) return;
						if(get.tag(card,'respondShan')){
							for(var i=0;i<game.players.length;i++){
								if(game.players[i].get('e','2')){
									if(ai.get.attitude(player,game.players[i])>0) return 0.6/player.num('he');
									return;
								}
							}
						}
						if(get.tag(card,'respondSha')){
							for(var i=0;i<game.players.length;i++){
								if(game.players[i].get('e','1')){
									if(ai.get.attitude(player,game.players[i])>0) return 0.6/player.num('he');
									return;
								}
							}
						}
					}
				}
			},
		},
		huajian:{
			trigger:{player:'phaseUseEnd'},
			direct:true,
			filter:function(event,player){
				return player.num('he')>0;
			},
			content:function(){
				"step 0"
				var next=player.chooseCardTarget({
					position:'he',
					filterTarget:function(card,player,target){
						return lib.filter.targetEnabled({name:'sha'},player,target);
					},
					filterCard:true,
					ai1:function(card){
						return ai.get.unuseful(card)+9;
					},
					ai2:function(target){
						return ai.get.effect(target,{name:'sha'},player);
					},
					prompt:get.prompt('huajian')
				});
				"step 1"
				if(result.bool){
					player.logSkill('huajian');
					player.useCard({name:'sha'},result.cards,result.targets,false);
				}
			},
			ai:{
				expose:0.2,
			}
		},
		polang:{
			trigger:{source:'damageEnd'},
			// group:'unequip',
			check:function(event,player){
				return ai.get.attitude(player,event.player)<0;
			},
			filter:function(event,player){
				return event.player.num('e');
			},
			direct:true,
			content:function(){
				player.discardPlayerCard(trigger.player,'e',get.prompt('polang',trigger.player)).logSkill='polang';
			},
			ai:{
				expose:0.3
			},
		},
		jikong:{
			trigger:{player:['loseEnd','phaseBegin']},
			direct:true,
			filter:function(event,player){
				if(event.name=='phase') return true;
				if(player.num('h')) return false;
				for(var i=0;i<event.cards.length;i++){
					if(event.cards[i].original=='h') return true;
				}
				return false;
			},
			content:function(){
				"step 0"
				player.chooseTarget(get.prompt('jikong'),function(card,player,target){
					return lib.filter.targetEnabled({name:'sha',nature:'thunder'},player,target);
				}).ai=function(target){
					return ai.get.effect(target,{name:'sha',nature:'thunder'},player);
				}
				"step 1"
				if(result.bool){
					player.logSkill('jikong');
					player.useCard({name:'sha',nature:'thunder'},result.targets,false);
				}
			},
			ai:{
				threaten:function(player,target){
					if(target.num('h')) return 0.8;
					return 2;
				}
			}
		},
		xielei:{
			trigger:{player:['useCard','respondAfter']},
			direct:true,
			filter:function(event){
				return game.players.length>2&&event.card&&event.card.name=='sha';
			},
			content:function(){
				"step 0"
				game.delay(0.5);
				player.chooseCardTarget({
					prompt:get.prompt('xielei'),
					filterCard:lib.filter.cardDiscardable,
					position:'he',
					filterTarget:function(card,player,target){
						if(player==target) return false;
						if(trigger.name=='respond'){
							return trigger.source!=target;
						}
						else{
							return !trigger.targets.contains(target);
						}
					},
					ai1:function(card){
						return 8-ai.get.value(card);
					},
					ai2:function(target){
						return ai.get.damageEffect(target,player,player,'thunder');
					}
				});
				"step 1"
				if(result.bool){
					player.logSkill('xielei',result.targets,'thunder');
					player.discard(result.cards);
					result.targets[0].damage('thunder');
				}
			},
			ai:{
				expose:0.3,
				threaten:1.6
			}
		},
		jingjie:{
			enable:'phaseUse',
			init:function(player){
				player.storage.jingjie=false;
			},
			mark:true,
			intro:{
				content:'limited',
			},
			filter:function(event,player){
				return !player.storage.jingjie;
			},
			content:function(){
				'step 0'
				player.storage.jingjie=true;
				player.unmarkSkill('jingjie');
				for(var i=0;i<game.players.length;i++){
					game.players[i].discard(game.players[i].get('hej'))._triggered=null;
				}
				'step 1'
				for(var i=0;i<game.players.length;i++){
					game.players[i].directgain(get.cards(2));
					game.players[i].$draw(2);
				}

			},
			ai:{
				threaten:1.3,
				order:1,
				result:{
					player:function(player){
						var num=0;
						for(var i=0;i<game.players.length;i++){
							var att=ai.get.attitude(player,game.players[i]);
							if(att>0){
								num-=game.players[i].num('he')-2;
							}
							else if(att<0){
								num+=game.players[i].num('he')-2;
							}
						}
						if(player.hp==1) return num-1;
						return num-game.players.length/2;
					}
				}
			}
		},
		ningjian:{
			group:['ningjian1','ningjian2'],
			ai:{
				effect:{
					target:function(card,player,target){
						if(target.num('he')&&(get.tag(card,'respondShan')||get.tag(card,'respondSha'))) return 0.6
					}
				},
				respondSha:true,
				respondShan:true,
			}
		},
		ningjian1:{
			enable:['chooseToRespond','chooseToUse'],
			filterCard:{color:'black'},
			viewAs:{name:'sha'},
			position:'he',
			prompt:'将一张黑色牌当杀打出',
			check:function(card){return 6-ai.get.value(card)}
		},
		ningjian2:{
			enable:['chooseToRespond','chooseToUse'],
			filterCard:{color:'red'},
			viewAs:{name:'shan'},
			position:'he',
			prompt:'将一张红色牌当闪打出',
			check:function(card){return 6-ai.get.value(card)}
		},
		duoren:{
			trigger:{target:'shaMiss'},
			filter:function(event){
				return event.player.get('e','1')!=undefined;
			},
			check:function(event,player){
				return ai.get.attitude(player,event.player)<0;
			},
			priority:5,
			content:function(){
				trigger.player.$give(trigger.player.get('e','1'),player);
				player.gain(trigger.player.get('e','1'),trigger.player);
			},
			ai:{
				effect:{
					target:function(card,player,target,current){
						if(card.name=='sha'&&target.num('h')>1&&player.get('e','1')){
							return [1,0.5,0,-0.5];
						}
					}
				}
			}
			// filter:function(event){
			// 	return event.player.num('e')>0;
			// },
			// content:function(){
			// 	"step 0"
			// 	player.choosePlayerCard('是否获得'+get.translation(trigger.player)+'的一张装备牌？',
			// 	'e',trigger.player).ai=ai.get.buttonValue;
			// 	"step 1"
			// 	if(result.bool){
			// 		var card=result.buttons[0].link;
			// 		trigger.player.$give(card,player);
			// 		player.gain(card);
			// 	}
			// },
		},
		taixu:{
			enable:'phaseUse',
			filter:function(event,player){
				return (!player.storage.taixu)&&player.num('hej');
			},
			filterTarget:function(card,player,target){
				return player!=target&&target.hp>1;
			},
			content:function(){
				player.discard(player.get('hej'));
				player.storage.taixu=true;
				target.damage(player.maxHp-player.hp);
			},
			ai:{
				basic:{
					order:1,
				},
				result:{
					target:function(player,target){
						if(player.maxHp-player.hp<2) return 0;
						return -2;
					},
					player:function(player,target){
						return -0.5*player.num('he');
					}
				}
			}
		},
		pozhen:{
			trigger:{player:'damageEnd'},
			filter:function(event,player){
				return event.source&&event.source.num('h')!=player.num('h');
			},
			// check:function(event,player){
			// 	return ai.get.attitude(player,event.source)<0;
			// },
			direct:true,
			content:function(){
				"step 0"
				var num=player.num('h')-trigger.source.num('h');
				event.num=num;
				if(num>0){
					var next=player.chooseToDiscard(num,'是否弃置'+num+'张手牌，并对'+get.translation(trigger.source)+'造成一点伤害？');
					next.logSkill=['pozhen',trigger.source];
					next.ai=function(card){
						if(ai.get.damageEffect(trigger.source,player,player)>0&&num<=2){
							return 6-ai.get.value(card);
						}
						return -1;
					}
				}
				else if(num<0){
					player.chooseBool('是否弃置'+get.translation(trigger.source)+(-num)+'张手牌？').ai=function(){
						return ai.get.attitude(player,trigger.source)<0;
					}
				}
				else{
					event.finish();
				}
				"step 1"
				if(result.bool){
					if(event.num>0){
						trigger.source.damage();
					}
					else{
						player.logSkill('pozhen',trigger.source);
						var cards=trigger.source.get('h');
						cards.sort(lib.sort.random);
						trigger.source.discard(cards.slice(0,-event.num));
					}
				}
			},
			ai:{
				effect:{
					target:function(card,player,target){
						if(get.tag(card,'damage')){
							if(player.hasSkill('jueqing')) return [1,-1];
							var num=player.num('h')-target.num('h');
							if(num>0){
								return [1,0,0,-num/2];
							}
							if(num<0){
								return [1,0,0,-0.5];
							}
						}
					}
				}
			}
		},
		tanlin_defence:{
			trigger:{player:'damageEnd'},
			filter:function(event,player){
				return player.num('h')&&event.source&&event.source.num('h');
			},
			direct:true,
			content:function(){
				"step 0"
				player.chooseToDiscard([1,trigger.source.num('h')],'弃置任意张手牌并令伤害来源弃置等量手牌').ai=function(card){
					if(ui.selected.cards.length>=trigger.source.num('h')) return -1;
					if(ui.selected.cards.length==0) return 8-ai.get.value(card);
					return 4-ai.get.value(card);
				}
				"step 1"
				if(result.bool){
					player.logSkill('tanlin');
					trigger.source.discard(trigger.source.get('h',lib.sort.random,result.cards.length));
				}
				else{
					event.finish();
				}
				"step 2"
				player.draw();
			},
			ai:{
				effect:{
					target:function(card,player,target){
						if(get.tag(card,'damage')&&target.num('h')&&target.hp>1&&player!=target) return [1,0.2,0,-0.2];
					}
				}
			}
		},
		tanlin:{
			enable:'phaseUse',
			usable:1,
			group:'tanlin4',
			filterTarget:function(card,player,target){
				return player!=target&&target.num('h');
			},
			filter:function(event,player){
				return player.num('h')>0;
			},
			content:function(){
				"step 0"
				player.chooseToCompare(target).set('preserve','win');
				"step 1"
				if(result.bool){
					if(target.hasSkill('tanlin2')==false){
						target.addSkill('tanlin2');
						player.addSkill('tanlin3');
						player.gain([result.target]);
						player.$gain2([result.target]);
					}
				}
				else{
					player.damage(target);
				}
			},
			ai:{
				result:{
					target:function(player,target){
						var cards=player.get('h');
						var num=target.num('h');
						if(num>cards.length+3&&player.hp>1) return -2;
						if(num>cards.length+1&&player.hp>1) return -1;
						if(num==cards.length-1&&player.hp>1) return -1;
						for(var i=0;i<cards.length;i++){
							if(cards[i].number>9) return num==1?-1:-0.5;
						}
						return 0;
					}
				},
				order:9,
			}
		},
		tanlin2:{
			trigger:{global:'phaseAfter'},
			forced:true,
			content:function(){
				player.removeSkill('tanlin2');
			},
			// mod:{
			// 	cardEnabled:function(){
			// 		return false;
			// 	},
			// 	cardUsable:function(){
			// 		return false;
			// 	},
			// 	cardRespondable:function(){
			// 		return false;
			// 	},
			// 	cardSavable:function(){
			// 		return false;
			// 	}
			// },
		},
		tanlin3:{
			trigger:{global:'phaseAfter'},
			forced:true,
			popup:false,
			content:function(){
				player.removeSkill('tanlin3');
			},
			mod:{
				cardUsable:function(card,player,num){
					if(card.name=='sha') return num+1;
				}
			},
		},
		tanlin4:{
			mod:{
				targetInRange:function(card,player,target,now){
					if(target.hasSkill('tanlin2')) return true;
				},
			},
		},
		yunchou:{
			enable:'phaseUse',
			usable:1,
			filterTarget:function(card,player,target){
				return player!=target&&target.num('h');
			},
			filterCard:true,
			selectCard:[1,Infinity],
			content:function(){
				"step 0"
				var card=target.get('h').randomGet();
				target.discard(card);
				var color=get.color(card);
				var suit=get.suit(card);
				var num1=0,num2=0;
				for(var i=0;i<cards.length;i++){
					if(get.color(cards[i])==color) num1++;
					else num2++;
					// if(get.suit(cards[i])==suit) num1++;
				}
				event.num1=num1;
				event.num2=num2;
				"step 1"
				player.draw(event.num1);
				"step 2"
				target.draw(event.num2);
			},
			check:function(card){
				if(ui.selected.cards.length) return 0;
				return 4-ai.get.value(card);
			},
			ai:{
				order:5,
				result:{
					target:-0.5
				},
				threaten:1.3
			}
		},
		jqimou:{
			trigger:{player:'damageEnd'},
			frequent:true,
			filter:function(event,player){
				return _status.currentPhase!=player;
			},
			content:function(){
				"step 0"
				var cards=get.cards(1);
				event.card=cards[0];
				player.gain(cards,'gain2','log');
				"step 1"
				var gained=event.card;
				if(lib.filter.filterCard(gained)){
					var next=player.chooseToUse();
					next.filterCard=function(card){
						return card==gained;
					};
					next.prompt='是否使用'+get.translation(gained)+'？';
					// if(get.select(lib.card[gained.name])[1]!=-1){
					// 	next.selectCard=-1;
					// }
				}
			},
			ai:{
				effect:{
					target:function(card,player,target){
						if(get.tag(card,'damage')&&_status.currentPhase!=target){
							if(player.hasSkill('jueqing')) return [1,-1.5];
							return [1,0.5];
						}
					}
				}
			}
		},
		lexue:{
			group:['lexue1','lexue2'],
		},
		lexue1:{
			trigger:{player:'phaseBegin'},
			forced:true,
			popup:false,
			content:function(){
				player.removeSkill(player.storage.lexue);
				switch(Math.floor(Math.random()*4)){
					case 0:if(lib.skill.zhiheng){player.addSkill('zhiheng'); player.storage.lexue='zhiheng';player.popup('zhiheng');}break;
					case 1:if(lib.skill.jizhi){player.addSkill('jizhi'); player.storage.lexue='jizhi';player.popup('jizhi');}break;
					case 2:if(lib.skill.dimeng){player.addSkill('dimeng'); player.storage.lexue='dimeng';player.popup('dimeng');}break;
					case 3:if(lib.skill.quhu){player.addSkill('quhu'); player.storage.lexue='quhu';player.popup('quhu');}break;
				}
			}
		},
		lexue2:{
			trigger:{player:'phaseEnd'},
			forced:true,
			popup:false,
			content:function(){
				player.removeSkill(player.storage.lexue);
				switch(Math.floor(Math.random()*4)){
					case 0:if(lib.skill.yiji){player.addSkill('yiji'); player.storage.lexue='yiji';player.popup('yiji');}break;
					case 1:if(lib.skill.jijiu){player.addSkill('jijiu'); player.storage.lexue='jijiu';player.popup('jijiu');}break;
					case 2:if(lib.skill.guidao){player.addSkill('guidao'); player.storage.lexue='guidao';player.popup('guidao');}break;
					case 3:if(lib.skill.fankui){player.addSkill('fankui'); player.storage.lexue='fankui';player.popup('fankui');}break;
				}
			}
		},
        tianshu_old:{
            unique:true,
            trigger:{player:'phaseEnd'},
            direct:true,
            init:function(player){
                player.storage.tianshu=[];
                player.storage.tianshu2={};
            },
            intro:{
                content:function(storage){
                    if(storage&&storage.length){
                        var str='已学习技能：';
                        for(var i=0;i<storage.length;i++){
                            if(i){
                                str+='、';
                            }
                            str+=get.translation(storage[i]);
                        }
                        return str;
                    }
                    else{
                        return '暂无已学习技能';
                    }
                }
            },
            mark:true,
            filter:function(event,player){
                return player.num('he')>0;
            },
            content:function(){
				'step 0'
				player.chooseToDiscard('he',get.prompt('tianshu')).ai=function(card){
					if(get.position(card)=='h') return 5-ai.get.useful(card);
					return 4-ai.get.value(card);
				}.logSkill='tianshu';
				'step 1'
				if(result.bool){
					var list=[];
					for(var i in lib.character){
						if(lib.character[i][4]&&(lib.character[i][4].contains('boss')||lib.character[i][4].contains('hiddenboss'))) continue;
						if(i==player.name||i==player.name1||i==player.name2) continue;
						for(var j=0;j<lib.character[i][3].length;j++){
							if(!lib.skill[lib.character[i][3][j]].unique){
								list.push(i);break;
							}
						}
					}
					player.chooseButton(['选择角色',[list.randomGets(3),'character']],true);
				}
				else{
					event.finish();
				}
				'step 2'
				player.storage.tianshu_learn=result.links[0];
				//
                // var target=trigger.targets[0];
                // var names=[];
                // var list=[];
                // if(target.name&&!target.classList.contains('unseen')) names.add(target.name);
                // if(target.name1&&!target.classList.contains('unseen')) names.add(target.name1);
                // if(target.name2&&!target.classList.contains('unseen2')) names.add(target.name2);
                // var pss=player.get('s');
                // 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(player.storage.tianshu.contains(skills[j])) continue;
                //             if(lib.translate[skills[j]+'_info']&&lib.skill[skills[j]]&&
                //                 !lib.skill[skills[j]].unique&&!pss.contains(skills[j])){
                //                 list.add(skills[j]);
                //             }
                //         }
                //     }
                // }
                // var skill=list.randomGet();
                // player.storage.tianshu.push(skill);
                // player.storage.tianshu2.push(target);
                // player.popup(skill);
                // player.syncStorage('tianshu');
                // player.updateMarks();
                // game.log(player,'学习了','【'+get.translation(skill)+'】');
            },
            group:'tianshu2',
			ai:{
				threaten:2
			}
        },
        tianshu2:{
            enable:'phaseUse',
            filter:function(event,player){
                return !player.hasSkill('tianshu3')&&player.storage.tianshu&&player.storage.tianshu.length>0;
            },
            intro:{
                nocount:true
            },
            delay:0,
            content:function(){
                'step 0'
                var list=player.storage.tianshu;
                if(player.additionalSkills.tianshu){
                    player.removeSkill(player.additionalSkills.tianshu);
				}
				event.skillai=function(list){
					return list.randomGet();
				};
				if(event.isMine()){
                    var dialog=ui.create.dialog();
    				dialog.add('选择获得一项技能');
    				_status.event.list=list;
    				var clickItem=function(){
    					_status.event._result=this.link;
    					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" 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.dialog=dialog;
					event.switchToAuto=function(){
						event._result=event.skillai(list);
						game.resume();
					};
					game.pause();
                    _status.imchoosing=true;
				}
				else{
					event._result=event.skillai(list);
				}
				"step 1"
                _status.imchoosing=false;
				if(event.dialog){
					event.dialog.close();
				}
				var link=result;
				player.addSkill(link);
				player.skills.remove(link);
				player.additionalSkills.tianshu=link;
				player.popup(link);
                var target=player.storage.tianshu2[player.storage.tianshu.indexOf(link)];
                player.markSkillCharacter('tianshu2',target,get.translation(link),lib.translate[link+'_info']);
				player.checkMarks();
				player.addSkill('tianshu3');
            },
            ai:{
                order:10,
                result:{
                    player:function(player){
                        return 1;
                    }
                }
            }
        },
        tianshu3:{
			trigger:{global:['useCardAfter','useSkillAfter','phaseAfter']},
			forced:true,
			popup:false,
			silent:true,
			filter:function(event){
				return event.skill!='tianshu2';
			},
			content:function(){
				player.removeSkill('tianshu3');
			}
		},
		tianshu:{
			unique:true,
			enable:'phaseUse',
			filterCard:function(card){
				return get.type(card,'trick')=='trick';
			},
			discard:false,
			prepare:'give',
			filter:function(event,player){
				return player.num('h',{type:['trick','delay']})>0;
			},
			filterTarget:function(card,player,target){
				var names=[];
				if(target.name&&!target.classList.contains('unseen')) names.add(target.name);
				if(target.name1&&!target.classList.contains('unseen')) names.add(target.name1);
				if(target.name2&&!target.classList.contains('unseen2')) names.add(target.name2);
				var pss=player.get('s');
				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(lib.translate[skills[j]+'_info']&&lib.skill[skills[j]]&&
								!lib.skill[skills[j]].unique&&!pss.contains(skills[j])){
								return true;
							}
						}
					}
					return false;
				}
			},
			group:'tianshu_remove',
			createDialog:function(player,target,onlylist){
				var names=[];
				var list=[];
				if(target.name&&!target.classList.contains('unseen')) names.add(target.name);
				if(target.name1&&!target.classList.contains('unseen')) names.add(target.name1);
				if(target.name2&&!target.classList.contains('unseen2')) names.add(target.name2);
				var pss=player.get('s');
				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(lib.translate[skills[j]+'_info']&&lib.skill[skills[j]]&&
								!lib.skill[skills[j]].unique&&
								!pss.contains(skills[j])){
								list.push(skills[j]);
							}
						}
					}
				}
				if(onlylist) return list;
				var dialog=ui.create.dialog();
				dialog.add('选择获得一项技能');
				_status.event.list=list;
				var clickItem=function(){
					_status.event._result=this.link;
					game.resume();
				};
				for(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" 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'));
				return dialog;
			},
			check:function(card){
				return 5-ai.get.value(card);
			},
			content:function(){
				"step 0"
				target.gain(cards,player);
				event.skillai=function(list){
					return list.randomGet();
				};
				if(event.isMine()){
					event.dialog=lib.skill.tianshu.createDialog(player,target);
					event.switchToAuto=function(){
						event._result=event.skillai(event.list);
						game.resume();
					};
					_status.imchoosing=true;
					game.pause();
				}
				else{
					event._result=event.skillai(lib.skill.tianshu.createDialog(player,target,true));
				}
				"step 1"
				_status.imchoosing=false;
				if(event.dialog){
					event.dialog.close();
				}
				var link=result;
				player.addAdditionalSkill('tianshu',link);
				player.popup(link);
				player.markSkillCharacter('tianshu',target,get.translation(link),lib.translate[link+'_info']);
				player.storage.tianshu=target;
				player.checkMarks();
				game.log(player,'获得了技能','【'+get.translation(link)+'】');
			},
			ai:{
				order:1,
				result:{
					player:function(player,target){
						if(ai.get.attitude(player,target)<0) return 0;
						if(player.num('h')>player.hp) return 1;
						return 0;
					},
					target:function(player,target){
						if(ai.get.attitude(player,target)<0) return 0;
						if(player.num('h')>target.num('h')) return 1;
						return 0;
					}
				}
			}
		},
		tianshu_remove:{
			trigger:{global:'dieAfter'},
			forced:true,
			popup:false,
			silent:true,
			filter:function(event,player){
				return event.player==player.storage.tianshu;
			},
			content:function(){
				player.unmarkSkill('tianshu');
				player.removeAdditionalSkill('tianshu');
				delete player.storage.tianshu;
			}
		},
		tianshu2_old:{
			trigger:{player:'phaseBegin'},
			direct:true,
			priority:-9,
			content:function(){
				"step 0"
				player.chooseTarget(get.prompt('tianshu'),lib.skill.tianshu.filterTarget).ai=function(target){
					if(target.maxHp<5) return Math.random()*(5-target.maxHp);
					return -1;
				};
				"step 1"
				if(result.bool){
					player.logSkill('tianshu',result.targets);
					event.target=result.targets[0];
					if(event.isMine()){
						ui.auto.hide();
						event.dialog=lib.skill.tianshu.createDialog(player,result.targets[0]);
						game.pause();
					}
					else{
						var target=result.targets[0];
						var names=[];
						var list=[];
						if(target.name&&!target.classList.contains('unseen')) names.add(target.name);
						if(target.name1&&!target.classList.contains('unseen')) names.add(target.name1);
						if(target.name2&&!target.classList.contains('unseen2')) names.add(target.name2);
						var pss=player.get('s');
						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(lib.translate[skills[j]+'_info']&&lib.skill[skills[j]]&&
										!lib.skill[skills[j]].unique&&
										!pss.contains(skills[j])){
										list.push(skills[j]);
									}
								}
							}
						}
						if(!list.length){
							event.finish();
						}
						else{
							event._result=list.randomGet();
						}
					}
				}
				else{
					event.finish();
				}
				"step 2"
				if(player.storage.tianshu){
					player.unmark(player.storage.tianshu+'_charactermark');
				}
				ui.auto.show();
				if(event.dialog){
					event.dialog.close();
				}
				var link=result;
				var target=event.target;
				player.addSkill(link);
				player.skills.remove(link);
				player.additionalSkills.tianshu=link;
				player.markCharacter(target.name,{
					name:get.translation(link),
					content:lib.translate[link+'_info']
				});
				game.addVideo('markCharacter',player,{
					name:'get.translation(link)',
					content:lib.translate[link+'_info'],
					id:'tianshu',
					target:target.name
				});
				player.storage.tianshu=target.name;
				player.checkMarks();
				player.popup(link);
			},
			ai:{
				expose:0.2,
				threaten:2
			}
		},
		luomei:{
			trigger:{player:['useCard','respond']},
			frequent:true,
			filter:function(event,player){
				if(!event.cards) return false;
				if(event.cards.length!=1) return false;
				for(var i=0;i<event.cards.length;i++){
					if(get.suit(event.cards[i])=='club') return true;
				}
				return false;
			},
			content:function(){
				var num=0;
				for(var i=0;i<trigger.cards.length;i++){
					if(get.suit(trigger.cards[i])=='club') num++;
				}
				player.draw(num);
			}
		},
		xingdian:{
			enable:'phaseUse',
			usable:1,
			filterCard:true,
			filter:function(event,player){
				return player.num('h')>0;
			},
			filterTarget:function(card,player,target){
				return player!=target&&target.num('he')>0;
			},
			check:function(card){
				return 7-ai.get.value(card);
			},
			selectTarget:[1,2],
			content:function(){
				target.chooseToDiscard(true,'he');
			},
			ai:{
				order:9,
				result:{
					target:function(player,target){
						if(target.num('he')==1) return -1.5;
						return -1;
					}
					// player:function(player){
					// 	var num=0;
					// 	for(var i=0;i<game.players.length;i++){
					// 		if(game.players[i]!=player){
					// 			if(ai.get.attitude(player,game.players[i])>0) num--;
					// 			else num++;
					// 		}
					// 	}
					// 	return num;
					// }
				},
			}
		},
		yulin:{
			trigger:{player:'damageBefore'},
			priority:-10,
			filter:function(event,player){
				return player.num('he',{type:'equip'});
			},
			direct:true,
			content:function(){
				"step 0"
				var next=player.chooseToDiscard('he','是否弃置一张装备牌抵消伤害？',function(card,player){
					return get.type(card)=='equip';
				});
				next.logSkill='yulin';
				next.ai=function(card){
					if(player.hp==1||trigger.num>1){
						return 9-ai.get.value(card);
					}
					if(player.hp==2){
						return 8-ai.get.value(card);
					}
					return 7-ai.get.value(card);
				};
				"step 1"
				if(result.bool){
					game.delay();
					trigger.untrigger();
					trigger.finish();
				}
			}
		},
		funiao:{
			enable:'phaseUse',
			discard:false,
			prepare:'give2',
			filterTarget:function(card,player,target){
				if(player==target) return false;
				if(player.num('h')==0) return false;
				if(target.storage.funiao) return false;
				return true;
			},
			filterCard:true,
			check:function(card){
				if(card.name=='du') return 20;
				if(get.owner(card).num('h')<get.owner(card).hp) return 0;
				return 4-ai.get.value(card);
			},
			content:function(){
				"step 0"
				target.gain(cards,player);
				target.storage.funiao=true;
				target.addSkill('funiao2');
				// game.delay();
				"step 1"
				if(event.isMine()){
					event.dialog=ui.create.dialog(get.translation(target.name)+'的手牌',target.get('h'));
					game.pause();
					ui.create.confirm('o');
				}
				else{
					event.finish();
				}
				"step 2"
				event.dialog.close();
			},
			ai:{
				result:{
					target:function(player,target){
						if(ui.selected.cards.length&&ui.selected.cards[0].name=='du'){
							return -1;
						}
						return 1;
					},
				},
				order:1
			}
		},
		funiao2:{
			trigger:{global:'phaseUseEnd'},
			forced:true,
			popup:false,
			content:function(){
				player.storage.funiao=false;
			}
		},
		xuehuang:{
			enable:'phaseUse',
			usable:1,
			filterCard:{color:'red'},
			nodelay:true,
			check:function(card){return 6-ai.get.value(card);},
			filterTarget:function(card,player,target){
				return get.distance(player,target)<=1||player==target;
			},
			filter:function(event,player){
				return player.num('h',{color:'red'})>0;
			},
			selectTarget:-1,
			content:function(){
				target.damage('fire');
			},
			line:'fire',
			ai:{
				order:1,
				result:{
					target:function(player,target){
						var eff=ai.get.damageEffect(target,player,target,'fire');
						if(player==target&&player.hp<=1&&eff<0){
							eff*10;
						}
						return eff;
					}
				}
			}
		},
		zhuyu:{
			trigger:{global:'damageBegin'},
			filter:function(event,player){
				if(!event.player.isLinked()) return false;
				if(event.nature=='fire') return false;
				if(player.num('he',{color:'red'})) return true;
				return false;
			},
			direct:true,
			content:function(){
				"step 0"
				var next=player.chooseToDiscard('朱羽：是否弃置一张红色牌使'+get.translation(trigger.player)+'受到一点火焰伤害？','he',function(card){
					return get.color(card)=='red';
				});
				next.logSkill=['zhuyu',trigger.player,'fire'];
				next.ai=function(card){
					if(trigger.player.hasSkillTag('nofire')) return 0;
					if(ai.get.damageEffect(trigger.player,player,player,'fire')>0){
						return 9-ai.get.value(card);
					}
					return 0;
				};
				"step 1"
				if(result.bool){
					trigger.player.damage('fire');
				}
			}
		},
		ningshuang:{
			trigger:{target:'useCardToBegin'},
			filter:function(event,player){
				if(get.color(event.card)!='black') return false;
				if(!event.player) return false;
				if(event.player==player) return false;
				if(event.player.isLinked()&&event.player.isTurnedOver()) return false;
				if(player.num('he',{color:'black'})) return true;
				return false;
			},
			direct:true,
			content:function(){
				"step 0"
				var next=player.chooseToDiscard('是否弃置一张黑色牌使其横置或翻面？','he',function(card){
					return get.color(card)=='black';
				});
				next.logSkill='ningshuang';
				next.ai=function(card){
					if(ai.get.attitude(player,trigger.player)<0){
						return 9-ai.get.value(card);
					}
					return 0;
				};
				"step 1"
				if(result.bool){
					if(trigger.player.isTurnedOver()){
						trigger.player.loseHp();
					}
					if(trigger.player.isLinked()){
						trigger.player.turnOver();
					}
					else{
						trigger.player.link();
						player.draw();
					}
				}
			},
			ai:{
				effect:{
					target:function(card,player,target){
						if(get.color(card)=='black'&&ai.get.attitude(target,player)<0&&target.num('h')>0){
							return [1,0.1,0,-target.num('h')/4];
						}
					}
				}
			}
		},
		zaowu_old:{
			enable:'phaseUse',
			usable:1,
			position:'he',
			filterCard:function(card,player,target){
				if(ui.selected.cards.length==0) return true;
				for(var i=0;i<ui.selected.cards.length;i++){
					if(get.type(ui.selected.cards[i],'trick')==get.type(card,'trick')) return false;
				}
				return true;
			},
			selectCard:3,
			check:function(card){
				return 10-ai.get.value(card);
			},
			content:function(){
				"step 0"
				var list=[];
				var suit=['heart','diamond','club','spade'].randomGet();
				var number=Math.floor(Math.random()*13)+1;
				for(var i in lib.card){
					if(lib.card[i].mode&&lib.card[i].mode.contains(lib.config.mode)==false) continue;
					if(ai.get.value({name:i})>=10) continue;
					if(i!='list') list.push([suit,number,i]);
				}
				var dialog=ui.create.dialog([list,'vcard']);
				player.chooseButton(dialog,2,true,function(button){
					return ai.get.value({name:button.link[2]},player);
				});
				"step 1"
				var cards=[ui.create.card(),ui.create.card()];
				cards[0].init(result.buttons[0].link);
				cards[1].init(result.buttons[1].link);
				player.gain(cards);
				player.$gain(cards);
				game.delay();
			},
			ai:{
				order:8,
				result:{
					player:1
				},
				threaten:1.6
			}
		},
		xielv:{
			trigger:{player:'phaseDiscardEnd'},
			filter:function(event,player){
				var cards=player.get('h');
				if(cards.length<2) return false;
				var color=get.color(cards[0]);
				for(var i=1;i<cards.length;i++){
					if(get.color(cards[i])!=color) return false;
				}
				return true;
			},
			direct:true,
			content:function(){
				"step 0"
				var todiscard=[];
				var ainum=0;
				var cards;
				var att;
				var filter={color:get.color(player.get('h')[0])=='red'?'black':'red'};
				for(var i=0;i<game.players.length;i++){
					att=ai.get.attitude(player,game.players[i]);

					cards=game.players[i].get('e',filter);
					if(att>0){
						ainum-=cards.length;
					}
					else if(att<0){
						ainum+=cards.length;
					}
					todiscard=todiscard.concat(cards);

					cards=game.players[i].get('j',filter);
					if(att>0){
						ainum+=cards.length;
					}
					else if(att<0){
						ainum-=cards.length;
					}
					todiscard=todiscard.concat(cards);
				}
				var choice=[];
				if(player.hp<player.maxHp){
					choice.push('recover_hp');
				}
				if(todiscard.length){
					choice.push('discard_card');
				}
				choice.push('cancel2');
				if(choice.length>1){
					if(event.isMine()){
						event.dialog=ui.create.dialog(get.prompt('xielv'));
					}
					player.chooseControl(choice).ai=function(){
						if(choice.contains('recover_hp')) return 'recover_hp';
						else if(ainum>0) return 'discard_card';
						else return 'cancel2';
					}
					event.todiscard=todiscard;
					event.filter=filter;
				}
				else{
					event.finish();
				}
				"step 1"
				if(event.dialog) event.dialog.close();
				event.control=result.control;
				if(event.control!='recover_hp'&&event.control!='discard_card'){
					event.finish();
				}
				else{
					player.showHandcards();
					player.logSkill('xielv');
				}
				"step 2"
				if(event.control=='recover_hp'){
					player.recover();
					event.finish();
				}
				else if(event.control=='discard_card'){
					event.targets=game.players.slice(0);
					event.targets.sort(lib.sort.seat);
				}
				else{
					event.finish();
				}
				"step 3"
				if(event.targets&&event.targets.length){
					var target=event.targets.shift();
					target.discard(target.get('ej',event.filter));
					event.redo();
				}
			},
			ai:{
				expose:0.1,
			}
		},
		xiaomoyu:{
			trigger:{source:'damageEnd'},
			priority:1,
			forced:true,
			filter:function(event,player){
				return !player.hasSkill('xiaomoyu2');
			},
			content:function(){
				"step 0"
				player.addTempSkill('xiaomoyu2','phaseAfter');
				if(player.hp<player.maxHp){
					player.recover();
					event.finish();
				}
				else{
					player.draw();
					event.finish();
				}
				"step 1"
				if(result.control=='draw_card'){
					player.draw();
				}
				else{
					player.recover();
				}
			},
			ai:{
				maixie:true,
				effect:{
					target:function(card,player,target,current){
						if(card.name=='sha'&&(get.color(card)=='red')){
							return [1,-2];
						}
					}
				}
			}
		},
		xiaomoyu2:{},
		xielv_old:{
			trigger:{player:'phaseDiscardEnd'},
			filter:function(event,player){
				var cards=player.get('h');
				if(cards.length<2) return false;
				var color=get.color(cards[0]);
				for(var i=1;i<cards.length;i++){
					if(get.color(cards[i])!=color) return false;
				}
				return true;
			},
			content:function(){
				"step 0"
				player.showHandcards();
				"step 1"
				"step 2"
				var num=player.num('h');
				event.color=get.color(player.get('h')[0]);
				player.chooseTarget('选择至多'+num+'名角色各摸一张牌',[1,num],function(card,player,target){
					return true;
				}).ai=function(target){
					return ai.get.attitude(player,target);
				}
				"step 3"
				if(result.bool){
					event.num=0;
					event.targets=result.targets;
				}
				else{
					event.finish();
				}
				"step 4"
				if(event.num<event.targets.length){
					event.current=event.targets[event.num]
					event.current.draw();
				}
				else{
					event.finish();
				}
				"step 5"
				var renum=event.current.num('e',{color:event.color});
				if(renum){
					event.current.recover();
				}
				event.num++;
				event.goto(4);
			},
			ai:{
				threaten:1.4,
				expose:0.1,
			}
		},
		xiangu:{
			mod:{
				maxHandcard:function(player,num){
					if(player.hp<player.maxHp) return num+player.maxHp-player.hp;
				}
			},
		},
		tianhuo:{
			enable:'phaseUse',
			filterTarget:function(card,player,target){
				return target.num('j')>0;
			},
			usable:1,
			selectTarget:-1,
			filter:function(){
				for(var i=0;i<game.players.length;i++){
					if(game.players[i].num('j')) return true;
				}
				return false;
			},
			line:'fire',
			content:function(){
				"step 0"
				event.num=target.num('j');
				target.discard(target.get('j'));
				"step 1"
				target.damage(event.num,'fire','nosource')
			},
			ai:{
				order:1,
				result:{
					target:function(player,target){
						var eff=ai.get.damageEffect(target,player,target,'fire');
						if(eff>=0) return eff+1;
						var judges=target.get('j');
						if(!judges.length) return 0;
						if(target.hp==1||judges.length>1) return -judges.length;
						var name=judges[0].viewAs||judges[0].name;
						if(name=='shandian'||name=='huoshan'||name=='hongshui') return -judges.length;
						return 0;
					}
				}
			}
		},
		huanyin:{
			trigger:{target:'useCardToBefore'},
			forced:true,
			priority:5.9,
			filter:function(event,player){
				return event.player!=player;
			},
			content:function(){
				"step 0"
				var effect=ai.get.effect(player,trigger.card,trigger.player,player);
				player.judge(function(card){
					switch(get.suit(card)){
						case 'spade':return -effect;
						case 'heart':return 1;
						default:return 0;
					}
				});
				"step 1"
				switch(result.suit){
					case 'spade':{
						trigger.untrigger();
						trigger.finish();
						break;
					}
					case 'heart':{
						player.draw();
						break;
					}
				}
			},
			ai:{
				effect:{
					target:function(card,player,target){
						return 0.7
					}
				},
				threaten:0.8
			}
		},
		xuanzhou:{
			enable:'phaseUse',
			usable:1,
			discard:false,
			filter:function(event,player){
				return player.num('he',{type:'trick'})>0;
			},
			prepare:'throw',
			position:'he',
			filterCard:{type:'trick'},
			filterTarget:function(card,player,target){
				return player!=target;
			},
			check:function(card){
				return 7-ai.get.value(card);
			},
			content:function(){
				"step 0"
				var list=[];
				for(var i in lib.card){
					if(lib.card[i].mode&&lib.card[i].mode.contains(lib.config.mode)==false) continue;
					if(lib.card[i].type=='delay') list.push([cards[0].suit,cards[0].number,i]);
				}
				var dialog=ui.create.dialog([list,'vcard']);
				var bing=target.num('h')<=1;
				player.chooseButton(dialog,true,function(button){
					if(bing&&button.link[2]=='bingliang'){
						return 2;
					}
					if(button.link[2]=='lebu'){
						return 1;
					}
					if(button.link[2]=='guiyoujie'){
						return 0.5;
					}
					return 0.2;
				}).filterButton=function(button){
					return !target.hasJudge(button.link[2]);
				};
				"step 1"
				// console.log(result.links[0][2]);
				target.addJudge(result.links[0][2],cards);
			},
			ai:{
				result:{
					target:-1
				},
				order:9.5,
			}
		},
		tianlun:{
			unique:true,
			trigger:{global:'judge'},
			direct:true,
			filter:function(event){
				if(event.card) return true;
				for(var i=0;i<game.players.length;i++){
					if(game.players[i].num('j')) return true;
				}
				return false;
			},
			content:function(){
				"step 0"
				var list=[];
				if(trigger.card) list.push(trigger.card);
				for(var i=0;i<game.players.length;i++){
					list=list.concat(game.players[i].get('j'));
				}
				var dialog=ui.create.dialog(get.translation(trigger.player)+'的'+(trigger.judgestr||'')+'判定为'+get.translation(trigger.player.judging[0])+
					'，'+get.prompt('tianlun'),list,'hidden');
				player.chooseButton(dialog,function(button){
					var card=button.link;
					var trigger=_status.event.parent._trigger;
					var player=_status.event.player;
					var result=trigger.judge(card)-trigger.judge(trigger.player.judging[0]);
					var attitude=ai.get.attitude(player,trigger.player);
					return result*attitude;
				});
				"step 1"
				if(result.bool){
					event.card=result.buttons[0].link;
					if(get.owner(event.card)) get.owner(event.card).discard(event.card);
					else trigger.player.$throw(event.card,1000);
					if(event.card.clone){
						event.card.clone.classList.add('thrownhighlight');
						game.addVideo('highlightnode',player,get.cardInfo(event.card));
					}
				}
				"step 2"
				if(event.card){
					player.logSkill('tianlun',trigger.player);
					ui.discardPile.appendChild(trigger.player.judging[0]);
					trigger.player.judging[0]=event.card;
					trigger.position.appendChild(event.card);
					game.log(trigger.player,'的判定牌改为',event.card);
					event.card.expired=true;
					game.delay(2);
				}
			},
			ai:{
				tag:{
					rejudge:0.6
				}
			}
		},
		hlongyin:{
			enable:'phaseUse',
			usable:1,
			filterCard:function(card,player){
				if(get.number(card)%game.players.length==0) return false;
				for(var i=0;i<game.players.length;i++){
					if(get.distance(player,game.players[i],'absolute')==get.number(card)%game.players.length){
						break;
					}
				}
				if(!game.players[i]) return false;
				if(game.players[i].num('e')==0) return false;
				for(var i=0;i<ui.selected.cards.length;i++){
					if(get.number(card)%game.players.length==
						get.number(ui.selected.cards[i])%game.players.length) return false;
					if(get.color(card)!=get.color(ui.selected.cards[i])) return false;
				}
				return true;
			},
			selectCard:[1,Infinity],
			filterTarget:function(card,player,target){
				if(player==target) return false;
				if(target.num('ej')==0) return false;
				for(var i=0;i<ui.selected.cards.length;i++){
					if(get.number(ui.selected.cards[i])%game.players.length==
						get.distance(player,target,'absolute')) return true;
				}
				return false;
			},
			selectTarget:-1,
			content:function(){
				"step 0"
				if(target.num('e')){
					player.choosePlayerCard(target,true,'e');
				}
				"step 1"
				try{
					target.discard(1,result.buttons[0].link);
				}
				catch(e){}
				if(target==targets[targets.length-1]) player.draw(targets.length);
			},
			check:function(card){
				return 8-ai.get.value(card);
			},
			ai:{
				order:10,
				result:{
					target:-1
				}
			}
		},
		lanzhi_old:{
			trigger:{source:'damageBefore'},
			logTarget:'player',
			check:function(event,player){
				if(player.hp==1&&event.player.hp>1) return true;
				var eff=ai.get.damageEffect(event.player,player,player);
				if(player.hp==player.maxHp) return eff<0;
				return eff<=0;
			},
			content:function(){
				trigger.untrigger();
				trigger.finish();
				player.recover();
			},
		},
		lanzhi:{
			trigger:{player:'useCard'},
			filter:function(event,player){
				if(get.suit(event.card)=='club'){
					for(var i=0;i<game.players.length;i++){
						if(game.players[i].hp<game.players[i].maxHp&&game.players[i].hp<=player.hp){
							return true;
						}
					}
				}
				return false;
			},
			prompt:function(event,player){
				var list=[];
				for(var i=0;i<game.players.length;i++){
					if(game.players[i].hp<game.players[i].maxHp&&game.players[i].hp<=player.hp){
						list.push(game.players[i]);
					}
				}
				return get.prompt('lanzhi',list);
			},
			check:function(event,player){
				var list=[];
				for(var i=0;i<game.players.length;i++){
					if(game.players[i].hp<game.players[i].maxHp&&game.players[i].hp<=player.hp){
						list.push(game.players[i]);
					}
				}
				var num=0;
				for(var i=0;i<list.length;i++){
					var eff=ai.get.recoverEffect(list[i],player,player);
					if(eff>0){
						num++;
					}
					else{
						num--;
					}
				}
				return num>0;
			},
			content:function(){
				"step 0"
				var list=[];
				for(var i=0;i<game.players.length;i++){
					if(game.players[i].hp<game.players[i].maxHp&&game.players[i].hp<=player.hp){
						list.push(game.players[i]);
					}
				}
				player.line(list,'green');
				list.sort(lib.sort.seat);
				event.list=list;
				"step 1"
				if(event.list.length){
					event.list.shift().recover();
					event.redo();
				}
			},
			ai:{
				expose:0.3,
				threaten:1.5
			}
		},
		lanzhi2:{},
		duanyi:{
			enable:'phaseUse',
			usable:1,
			filter:function(event,player){
				return player.num('h','sha')>1;
			},
			filterCard:{name:'sha'},
			selectCard:2,
			filterTarget:function(card,player,target){
				return player!=target;
			},
			check:function(card){
				return 10-ai.get.value(card);
			},
			content:function(){
				"step 0"
				target.damage();
				"step 1"
				var he=target.get('he');
				target.discard(he.randomGets(target.maxHp-target.hp));
			},
			ai:{
				expose:0.3,
				result:{
					target:function(player,target){
						return ai.get.damageEffect(target,player)-(target.maxHp-target.hp)/2;
					}
				},
				order:5
			}
		},
		swd_xiuluo:{
			audio:2,
			trigger:{player:'phaseBegin'},
			direct:true,
			filter:function(event,player){
				return player.num('j')>0;
			},
			content:function(){
				"step 0"
				player.chooseToDiscard(2,'hj',function(card){
					if(ui.selected.cards.length==0) return true;
					if(get.position(ui.selected.cards[0])=='h'){
						if(get.position(card)!='j') return false;
					}
					if(get.position(ui.selected.cards[0])=='j'){
						if(get.position(card)!='h') return false;
					}
					return get.suit(card)==get.suit(ui.selected.cards[0])
				},'是否一张手牌来弃置一张花色相同的判定牌？').ai=function(card){
					if(get.position(card)=='h'){
						return 11-ai.get.value(card);
					}
					if(card.name=='lebu') return 5;
					if(card.name=='bingliang') return 4;
					if(card.name=='guiyoujie') return 3;
					return 2;
				}
				"step 1"
				if(result.bool){
					player.logSkill('swd_xiuluo');
				}
			}
		},
		guxing:{
			group:['guxing1','guxing3']
		},
		guxing1:{
			enable:'phaseUse',
			usable:1,
			filter:function(event,player){
				var min=Math.max(1,player.maxHp-player.hp);
				return player.num('h')<=min&&player.num('h')>0&&
					lib.filter.filterCard({name:'sha'},player);
			},
			filterCard:true,
			selectCard:-1,
			// viewAs:{name:'sha'},
			discard:false,
			prepare:'throw',
			filterTarget:function(card,player,target){
				return lib.filter.targetEnabled({name:'sha'},player,target);
			},
			content:function(){
				"step 0"
				delete player.storage.guxing;
				targets.sort(lib.sort.seat);
				player.useCard({name:'sha'},cards,targets,'guxing').animate=false;
				"step 1"
				if(player.storage.guxing){
					player.draw(player.storage.guxing);
					delete player.storage.guxing;
				}
			},
			multitarget:true,
			multiline:true,
			selectTarget:[1,3],
			ai:{
				order:function(){
					if(_status.event.player.num('h')==1) return 10;
					return lib.card.sha.ai.order+0.1;
				},
				result:{
					target:function(player,target){
						return ai.get.effect(target,{name:'sha'},player,target);
					}
				},
				threaten:function(player,target){
					if(target.hp<target.maxHp-1) return 1.5;
				},
				pretao:true
			}
		},
		guxing3:{
			trigger:{source:'damageAfter'},
			forced:true,
			popup:false,
			filter:function(event){
				return event.parent.skill=='guxing';
			},
			content:function(){
				if(!player.storage.guxing){
					player.storage.guxing=1;
				}
				else{
					player.storage.guxing++;
				}
			}
		},
		miles_xueyi:{
			trigger:{player:'damageBefore'},
			forced:true,
			priority:10,
			content:function(){
				trigger.untrigger();
				trigger.finish();
				player.loseHp();
			}
		},
		swdxueyi:{
			trigger:{player:'phaseDrawBegin'},
			frequent:true,
			content:function(){
				trigger.num+=player.maxHp-player.hp;
			},
			ai:{
				effect:{
					target:function(card,player,target){
						if(get.tag(card,'damage')){
							if(target.hp==target.maxHp) return [0,1];
						}
						if(get.tag(card,'recover')&&player.hp>=player.maxHp-1) return [0,0];
					}
				}
			}
		},
		jifeng:{
			mod:{
				selectTarget:function(card,player,range){
					if(range[0]!=1||range[1]!=1) return;
					var range2=get.select(get.info(card).selectTarget);
					if(range2[0]!=1&&range2[1]!=1) return;
					if(card.name=='sha'||get.type(card)=='trick') range[1]=Infinity;
				},
			},
			trigger:{player:'useCardToBefore'},
			priority:6,
			forced:true,
			popup:false,
			filter:function(event,player){
				if(event.targets.length<=1) return false;
				if(event.card.name=='sha') return true;
				else if(get.type(event.card)=='trick'){
					var range=get.select(get.info(event.card).selectTarget);
					if(range[0]==1&&range[1]==1) return true;
				}
				return false;
			},
			content:function(){
				if(Math.random()>(1.3+trigger.targets.length/5)/trigger.targets.length){
					trigger.target.popup('失误');
					trigger.untrigger();
					trigger.finish();
				}
			}
		},
		mohua2:{
			unique:true,
			trigger:{player:'dying'},
			priority:10,
			forced:true,
			content:function(){
				"step 0"
				player.removeSkill('miles_xueyi');
				player.removeSkill('aojian');
				player.removeSkill('mohua2');
				player.addSkill('moyan');
				player.addSkill('miedao');
				player.addSkill('jifeng');
				player.addSkill('swd_xiuluo');

				lib.character.swd_satan=['','qun',4,['moyan','miedao','jifeng','swd_xiuluo'],['temp']];
				if(player.name=='swd_miles') player.name='swd_satan';
				if(player.name1=='swd_miles') player.name1='swd_satan';
				if(player.name2=='swd_miles'){
					player.name2='swd_satan';
					player.node.avatar2.setBackground('swd_satan','character');
				}
				else{
					player.node.avatar.setBackground('swd_satan','character');
				}

				"step 1"
				player.recover(2);
				"step 2"
				player.draw(2);
			},
		},
		liexin:{
			trigger:{source:'damageBegin'},
			direct:true,
			content:function(){
				"step 0"
				player.chooseToDiscard('是否弃置一张牌使伤害+1？','he').ai=function(card){
					if(ai.get.attitude(player,trigger.player)<0){
						return 7-ai.get.value(card);
					}
				}
				"step 1"
				if(result.bool){
					player.logSkill('liexin');
					trigger.num++;
				}
			},
			ai:{
				threaten:1.8
			}
		},
		mohua:{
			trigger:{player:'dying'},
			priority:10,
			forced:true,
			mode:['identity'],
			content:function(){
				"step 0"
				var skills=['wuying','xiehun','jumo'];
				if(lib.config.mode_choice.double_character){
					skills.push('swd_xiuluo');
				}
				lib.character.swd_satan=['','qun',6,skills,['temp']];
				if(!_status.ai.customAttitude) _status.ai.customAttitude=[];
				_status.ai.customAttitude.push(function(from,to){
					if(from.storage.xiehun){
						if(to==game.zhu) return 10;
						return -10;
					}
					if(to.storage.xiehun){
						return 0;
					}
				});
				player.uninit();
				player.init('swd_satan');
				player.hp=game.players.length;
				player.update();
				game.zhu=player;
				player.identity='zhu';
				player.setIdentity('魔');
				player.identityShown=true;
				var players=get.players(false,true);
				for(var i=0;i<players.length;i++){
					if(players[i]!=player){
						players[i].identity='fan';
						players[i].setIdentity('人');
						players[i].identityShown=true;
					}
				}
				player.draw(2);
				"step 1"
				while(_status.event.name!='phaseLoop'){
					_status.event=_status.event.parent;
				}
				_status.event.player=player;
				_status.event.step=0;
				ui.clear();
			}
		},
		wuying:{
			mod:{
				selectTarget:function(card,player,range){
					if(card.name=='sha') {range[0]=-1;range[1]=-1;}
					if(get.type(card)=='trick'&&range[0]==1&range[1]==1) {range[0]=-1;range[1]=-1;}
				},
			},
		},
		xiehun:{
			group:['xiehun1','xiehun2'],
			intro:{
				content:'已陷入混乱状态',
				show:true,
			}
		},
		xiehun1:{
			trigger:{player:'phaseBegin'},
			forced:true,
			popup:false,
			content:function(){
				if(game.me.storage.xiehun) ui.auto.show();
				for(var i=0;i<game.players.length;i++){
					delete game.players[i].storage.xiehun;
				}
				if(ui.auto.innerHTML=='托管') _status.auto=false;
			}
		},
		xiehun2:{
			trigger:{source:'damageBegin'},
			filter:function(event,player){
				return event.player!=player;
			},
			forced:true,
			content:function(){
				trigger.player.storage.xiehun=true;
				if(trigger.player==game.me){
					_status.auto=true;
					ui.auto.hide();
				}
				// player.chooseToDiscard(true,'h');
			}
		},
		jumo2:{
			trigger:{player:'phaseDrawBegin'},
			forced:true,
			priority:-10,
			content:function(){
				var num=Math.max(2,game.players.length-1);
				if(lib.config.mode_choice.double_character){
					num++;
				}
				trigger.num=Math.min(4,num);
			}
		},
		jumo:{
			trigger:{player:'phaseEnd'},
			forced:true,
			content:function(){
				var num=0;
				for(var i=0;i<game.players.length;i++){
					if(player!=game.players[i]&&!game.players[i].storage.xiehun) num++;
				}
				num=2*num-game.players.length;
				if(get.config('double_character')){
					num++;
				}
				if(num>0){
					player.draw(num);
				}
			},
		},
		duijue:{
			enable:'phaseUse',
			mark:true,
			unique:true,
			forceunique:true,
			skillAnimation:true,
			filter:function(event,player){
				return !player.storage.duijue;
			},
			filterTarget:function(card,player,target){
				return player!=target&&target!=game.zhu;
			},
			content:function(){
				player.storage.duijue=true;
				player.awakenSkill('duijue');
				var evt=_status.event;
				for(var i=0;i<10;i++){
					if(evt&&evt.getParent){
						evt=evt.getParent();
					}
					if(evt.name=='phaseUse'){
						evt.skipped=true;
						break;
					}
				}
				player.storage.duijue3=target;
				player.addSkill('duijue3');
			},
			init:function(player){
				player.storage.duijue=false;
			},
			intro:{
				content:'limited'
			},
			ai:{
				order:1,
				result:{
					target:function(player,target){
						if(target.hp==1&&player.hp>=3) return -1;
						if(target.hp<player.hp&&target.num('h')<=player.num('h')) return -1;
						return 0;
					}
				}
			}
		},
		duijue3:{
			trigger:{player:'phaseAfter'},
			forced:true,
			popup:false,
			content:function(){
				'step 0'
				event.target=player.storage.duijue3;
				delete player.storage.duijue3;
				player.removeSkill('duijue3');
				for(var i=0;i<game.players.length;i++){
					if(game.players[i]!=player&&game.players[i]!=event.target){
						game.players[i].addSkill('duijue2');
					}
				}
				'step 1'
				target.phase();
				'step 2'
				if(target.isAlive()){
					player.phase();
				}
				else{
					event.goto(4);
				}
				'step 3'
				if(target.isAlive()){
					event.goto(1);
				}
				'step 4'
				for(var i=0;i<game.players.length;i++){
					if(game.players[i]!=player&&game.players[i]!=target){
						game.players[i].removeSkill('duijue2');
					}
				}
			}
		},
		duijue2:{
			mod:{
				cardEnabled:function(){
					return false;
				},
				cardSavable:function(){
					return false;
				},
				targetEnabled:function(){
					return false;
				}
			},
			init:function(player){
				player.classList.add('transparent');
			},
			onremove:function(player){
				player.classList.remove('transparent');
			},
			intro:{
				content:'不计入距离的计算且不能使用牌且不是牌的合法目标'
			},
			group:'undist'
		},
		yueren:{
			trigger:{player:'shaBegin'},
			filter:function(event,player){
				return !player.hasSkill('yueren2');
			},
			check:function(event,player){
				return ai.get.attitude(player,event.target)<=0;
			},
			content:function(){
				"step 0"
				player.judge(function(){
					return 0;
				});
				player.addTempSkill('yueren2','phaseAfter');
				"step 1"
				if(get.color(result.card)=='black'){
					if(trigger.target.num('he')){
						player.discardPlayerCard(true,trigger.target,'he');
						// trigger.target.discard(trigger.target.get('he').randomGet());
					}
				}
				else if(trigger.cards&&trigger.cards.length){
					player.gain(trigger.cards);
					player.$gain2(trigger.cards);
					game.log(player,'收回了',trigger.cards);
				}
			}
		},
		yueren2:{},
		busi:{
			trigger:{player:'dying'},
			priority:7,
			unique:true,
			forced:true,
			filter:function(event,player){
				return player.hp<=0;
			},
			content:function(){
				'step 0'
				player.judge(function(card){
					return get.suit(card)=='spade'?-1:1;
				});
				'step 1'
				if(result.bool){
					player.recover(1-player.hp);
					if(!player.isTurnedOver()){
						player.turnOver();
					}
				}
			},
			ai:{
				threaten:0.8
			}
		},
		busi_old:{
			unique:true,
			global:'busi2',
		},
		busi_old2:{
			trigger:{player:'phaseAfter'},
			forced:true,
			popup:false,
			content:function(){
				var target=player.nextSeat;
				while(target.isDead()&&target.hasSkill('busi')==false){
					target=target.nextSeat;
				}
				if(target.isDead()){
					target.revive(1);
					target.classList.add('turnedover');
					target.logSkill('busi');
				}
			},
			ai:{
				threaten:0.5,
			}
		},
		xuying:{
			unique:true,
			trigger:{player:'damageBefore'},
			forced:true,
			content:function(){
				trigger.untrigger();
				trigger.finish();
				if(player.num('h')) player.loseHp();
			},
			ai:{
				effect:{
					target:function(card,player,target){
						if(get.tag(card,'damage')&&target.num('h')==0) return 0;
					}
				}
			}
		},
		yinguo:{
			unique:true,
			trigger:{global:'damageBefore'},
			priority:6,
			direct:true,
			filter:function(event,player){
				if(event.player==player||event.source==player) return false;
				if(!event.source) return false;
				if(player.num('he')==0) return false;
				if(player.hasSkill('yinguo2')) return false;
				return true;
			},
			content:function(){
				"step 0"
				var go=ai.get.attitude(player,trigger.player)>0&&
					ai.get.attitude(player,trigger.source)<0&&
					ai.get.damageEffect(trigger.player,trigger.source,player)<
					ai.get.damageEffect(trigger.source,trigger.player,player);
				var next=player.chooseToDiscard('是否将伤害来源（'+get.translation(trigger.source)+
					'）和目标（'+get.translation(trigger.player)+'）对调？','he');
				next.ai=function(card){
					if(go){
						return 10-ai.get.value(card);
					}
					return 0;
				};
				next.logSkill='yinguo';
				"step 1"
				if(result.bool){
					var target=trigger.player;
					trigger.player=trigger.source;
					trigger.source=target;
					trigger.trigger('damageBefore');
					player.addTempSkill('yinguo2',['damageAfter','damageCancelled']);
				}
			},
			ai:{
				threaten:10,
				expose:0.5,
			},
			global:'yinguo3'
		},
		yinguo2:{},
		yinguo3:{
			ai:{
				effect:{
					target:function(card,player,target){
						if(!get.tag(card,'damage')) return;
						if(target.hasSkill('yinguo')) return;
						var source=null;
						for(var i=0;i<game.players.length;i++){
							if(game.players[i].hasSkill('yinguo')){
								source=game.players[i];
								break;
							}
						}
						if(source&&source.num('he')){
							if(ai.get.attitude(source,player)<0&&ai.get.attitude(source,target)>0){
								return [0,0,0,-1];
							}
						}
					}
				}
			}
		},
		guiyan:{
			unique:true,
			enable:'phaseUse',
			usable:1,
			intro:{
				content:'濒死时回复一点体力并失去鬼眼'
			},
			mark:true,
			filterTarget:function(card,player,target){
				return player!=target&&target.num('h');
			},
			content:function(){
				"step 0"
				player.chooseCardButton(target,target.get('h')).filterButton=function(button){
					return get.suit(button.link)=='club';
				}
				"step 1"
				if(result.bool){
					player.gain(result.links[0],target);
					target.$give(1,player);
					game.delay(0,500);
				}
			},
			ai:{
				order:11,
				result:{
					target:-1,
					player:1,
				},
				threaten:1.3
			},
			group:['guiyan2'],
		},
		guiyan2:{
			trigger:{player:'dying'},
			priority:6,
			forced:true,
			content:function(){
				player.recover();
				player.removeSkill('guiyan');
				player.removeSkill('guiyan2');
			}
		},
		yunshen_old:{
			mod:{
				globalFrom:function(from,to,distance){
					if(!from.get('e','1')) return distance-1;
				},
				globalTo:function(from,to,distance){
					if(!to.get('e','2')) return distance+1;
				}
			}
		},
		suiyan_old:{
			enable:'phaseUse',
			usable:1,
			filterCard:function(card){
				return get.type(card)=='basic';
			},
			filterTarget:function(card,player,target){
				return player!=target&&target.num('e');
			},
			content:function(){
				var num=Math.floor(Math.random()*3);
				if(num==0){
					player.draw();
				}
				else{
					target.discard(target.get('e').sort(lib.sort.random).splice(0,num));
				}
			},
			ai:{
				order:7,
				result:{
					target:-1,
				},
				threaten:1.2
			}
		},
		xianyin:{
			enable:'phaseUse',
			filter:function(event,player){
				for(var i=0;i<game.players.length;i++){
					if(game.players[i].num('j')&&game.players[i]!=player) return true;
				}
				return false;
			},
			content:function(){
				"step 0"
				event.targets=[];
				for(var i=0;i<game.players.length;i++){
					if(game.players[i].num('j')&&game.players[i]!=player){
						// game.players[i].gain(game.players[i].get('j'),'gain2');
						event.targets.add(game.players[i]);
					}
				}
				event.targets.sort(lib.sort.seat);
				"step 1"
				if(event.targets.length){
					event.target=event.targets.shift();
					event.target.discard(event.target.get('j'));
				}
				else{
					event.finish();
				}
				"step 2"
				if(event.target.num('h')){
					event.target.chooseCard('选择一张手牌交给'+get.translation(player),true).ai=function(card){
						return -ai.get.value(card);
					}
				}
				else{
					event.goto(1);
				}
				"step 3"
				if(result.bool){
					player.gain(result.cards[0],target);
					target.$give(1,player);
				}
				event.goto(1);
			},
			ai:{
				order:9,
				result:{
					player:function(player){
						var num=0;
						for(var i=0;i<game.players.length;i++){
							if(game.players[i]!=player&&game.players[i].num('j')){
								if(ai.get.attitude(player,game.players[i])>=0&&
									ai.get.attitude(game.players[i],player)>=0){
									num++;
								}
								else{
									num--;
								}
							}
						}
						return num;
					}
				}
			}
		},
		mailun:{
			unique:true,
			trigger:{player:'phaseBegin'},
			direct:true,
			intro:{
				content:function(storage){
					if(!storage) return '无';
					return lib.skill.mailun.effects[storage-1];
				}
			},
			effects:[
				'减少一点体力并增加一点体力上限',
				'增加一点体力并减少一点体力上限',
				'令你即将造成和即将受到的首次伤害-1',
				'令你即将造成和即将受到的首次伤害+1',
				'少摸一张牌并令手牌上限+1',
				'多摸一张牌并令手牌上限-1',
				'进攻距离+1，防御距离-1',
				'进攻距离-1，防御距离+1'
			],
			content:function(){
				"step 0"
				player.removeSkill('mailun31');
				player.removeSkill('mailun32');
				player.removeSkill('mailun41');
				player.removeSkill('mailun42');
				player.removeSkill('mailun5');
				player.removeSkill('mailun6');
				player.removeSkill('mailun7');
				player.removeSkill('mailun8');
				if(event.isMine()){
					ui.auto.hide();
					event.dialog=ui.create.dialog('脉轮：选择一个效果');
					var effects=lib.skill.mailun.effects;
					var clickItem=function(){
						event.choice=this.link;
						game.resume();
					}
					for(var i=0;i<8;i++){
						if(i==0&&player.maxHp==6) continue;
						var item=event.dialog.add('<div class="popup" style="width:70%;display:inline-block"><div class="skill">【'+
						get.cnNumber(i+1,true)+'】</div><div>'+effects[i]+'</div></div>');
						item.addEventListener('click',clickItem);
						item.link=i+1;

					}
					event.control=ui.create.control('取消',function(){
						event.choice=0;
						game.resume();
					});
					event.dialog.add(ui.create.div('.placeholder'));
					event.dialog.add(ui.create.div('.placeholder'));
					event.dialog.add(ui.create.div('.placeholder'));
					game.pause();
				}
				else{
					var ctrl;
					if(player.hp<=1){
						if(player.maxHp>3){
							ctrl=2;
						}
						else{
							ctrl=3;
						}
					}
					else if(player.hp==2){
						if(player.maxHp>4){
							ctrl=2;
						}
						else if(player.num('h')==0){
							ctrl=6;
						}
						else{
							ctrl=3;
						}
					}
					else if(player.num('h')<player.hp){
						ctrl=6;
					}
					else if(player.num('h')>player.hp+1){
						ctrl=5;
					}
					event.choice=ctrl;
				}
				"step 1"
				ui.auto.show();
				player.storage.mailun=event.choice;
				game.addVideo('storage',player,['mailun',player.storage.mailun]);
				if(event.choice){
					player.logSkill('mailun');
					player.markSkill('mailun');
					switch(event.choice){
						case 1:{
							player.loseHp();
							player.gainMaxHp();
							break;
						}
						case 2:{
							player.recover();
							player.loseMaxHp();
							break;
						}
						case 3:{
							player.addSkill('mailun31');
							player.addSkill('mailun32');
							break;
						}
						case 4:{
							player.addSkill('mailun41');
							player.addSkill('mailun42');
							break;
						}
						case 5:{
							player.addSkill('mailun5');
							break;
						}
						case 6:{
							player.addSkill('mailun6');
							break;
						}
						case 7:{
							player.addSkill('mailun7');
							break;
						}
						case 8:{
							player.addSkill('mailun8');
							break;
						}
					}
				}
				else{
					player.unmarkSkill('mailun');
				}

				if(event.dialog){
					event.dialog.close();
				}
				if(event.control){
					event.control.close();
				}
			}
		},
		mailun31:{
			trigger:{source:'damageBegin'},
			forced:true,
			content:function(){
				trigger.num--;
				player.removeSkill('mailun31');
			}
		},
		mailun32:{
			trigger:{player:'damageBegin'},
			forced:true,
			content:function(){
				trigger.num--;
				player.removeSkill('mailun32');
			}
		},
		mailun41:{
			trigger:{source:'damageBegin'},
			forced:true,
			content:function(){
				trigger.num++;
				player.removeSkill('mailun41');
			}
		},
		mailun42:{
			trigger:{player:'damageBegin'},
			forced:true,
			content:function(){
				trigger.num++;
				player.removeSkill('mailun42');
			}
		},
		mailun5:{
			trigger:{player:'phaseDrawBegin'},
			forced:true,
			popup:false,
			content:function(){
				trigger.num--;
			},
			mod:{
				maxHandcard:function(player,num){
					return num+1;
				}
			}
		},
		mailun6:{
			trigger:{player:'phaseDrawBegin'},
			forced:true,
			popup:false,
			content:function(){
				trigger.num++;
			},
			mod:{
				maxHandcard:function(player,num){
					return num-1;
				}
			}
		},
		mailun7:{
			mod:{
				globalFrom:function(from,to,distance){
					return distance-1;
				},
				globalTo:function(from,to,distance){
					return distance-1;
				}
			}
		},
		mailun8:{
			mod:{
				globalFrom:function(from,to,distance){
					return distance+1;
				},
				globalTo:function(from,to,distance){
					return distance+1;
				}
			}
		},
		fengming:{
			enable:'phaseUse',
			usable:1,
			filter:function(event,player){
				return player.num('he',{type:'equip'})>0;
			},
			filterCard:{type:'equip'},
			position:'he',
			filterTarget:true,
			content:function(){
				"step 0"
				target.recover();
				"step 1"
				target.draw();
			},
			ai:{
				order:9,
				result:{
					target:function(player,target){
						if(target.hp<target.maxHp){
							return ai.get.recoverEffect(target);
						}
					}
				}
			}
		},
		wanjun:{
			enable:'chooseToUse',
			filter:function(event,player){
				return player.num('he',{type:'equip'})>0;
			},
			filterCard:function(card){
				return get.type(card)=='equip';
			},
			position:'he',
			viewAs:{name:'nanman'},
			prompt:'将一张装备牌当南蛮入侵使用',
			check:function(card){
				var player=_status.currentPhase;
				if(player.num('he',{subtype:get.subtype(card)})>1){
					return 11-ai.get.equipValue(card);
				}
				if(player.num('h')<player.hp){
					return 6-ai.get.value(card);
				}
				return 2-ai.get.equipValue(card);
			},
			ai:{
				order:9,
				threaten:1.1
			}
		},
		huanling:{
			trigger:{player:'phaseEnd'},
			direct:true,
			content:function(){
				"step 0"
				player.chooseTarget(get.prompt('huanling'),function(card,player,target){
					return player!=target;
				}).ai=function(target){
					var att=ai.get.attitude(player,target);
					if(target.isTurnedOver()){
						if(att>0){
							return att+5;
						}
						return -1;
					}
					if(player.isTurnedOver()){
						return 5-att;
					}
					if(att<=-3){
						return -att;
					}
					return 0;
				};
				"step 1"
				if(result.bool){
					player.logSkill('huanling',result.targets);
					player.turnOver();
					result.targets[0].turnOver();
				}
			},
			group:'huanling2',
			ai:{
				effect:{
					target:function(card,player,target,current){
						if(card.name=='guiyoujie') return [0,2];
						if(target.isTurnedOver()){
							if(get.tag(card,'damage')) return 0;
						}
					}
				},
				expose:0.2
			}
		},
		huanling2:{
			trigger:{player:'damageBefore'},
			filter:function(event,player){
				return player.isTurnedOver();
			},
			forced:true,
			content:function(){
				trigger.untrigger();
				trigger.finish();
			},
		},
		ljifeng:{
			mod:{
				selectTarget:function(card,player,range){
					if(card.name=='sha'&&range[1]!=-1) range[1]+=player.maxHp-player.hp;
				},
				attackFrom:function(from,to,distance){
					return distance+from.hp-from.maxHp;
				}
			},
		},
		ljifeng_old:{
			trigger:{player:'phaseUseBefore'},
			direct:true,
			filter:function(event,player){
				return player.num('h')>0;
			},
			content:function(){
				"step 0"
				var check=player.num('h')<=player.hp+(player.hp>2?2:1);
				player.chooseCardTarget({
					prompt:get.prompt('ljifeng'),
					filterCard:lib.filter.cardDiscardable,
					filterTarget:function(card,player,target){
						if(player==target) return false;
						return player.canUse({name:'sha'},target,false);
					},
					selectTarget:[1,2],
					ai1:function(card){
						if(!check) return 0;
						return 8-ai.get.value(card);
					},
					ai2:function(target){
						if(!check) return 0;
						return ai.get.effect(target,{name:'sha'},player);
					}
				});
				"step 1"
				if(result.bool){
					player.logSkill('ljifeng',result.targets);
					player.discard(result.cards);
					player.useCard({name:'sha'},result.targets).animate=false;
					trigger.untrigger();
					trigger.finish();
				}
			}
		},
		lxianglong:{
			trigger:{target:'shaMiss'},
			priority:5,
			direct:true,
			content:function(){
				"step 0"
				player.chooseTarget(function(card,player,target){
					return player.canUse(trigger.card,target);
				},get.prompt('lxianglong')).ai=function(target){
					return ai.get.effect(target,trigger.card,player);
				}
				"step 1"
				if(result.bool){
					player.logSkill('lxianglong');
					player.line(result.targets);
					player.useCard(trigger.card,trigger.cards,result.targets).animate=false;
				}
			},
			ai:{
				effect:{
					target:function(card,player,target){
						if(card.name=='sha'&&target.num('h')) return 0.7;
					}
				}
			}
		},
		zhenjiu:{
			enable:'phaseUse',
			usable:1,
			filterCard:{color:'red'},
			filterTarget:function(card,player,target){
				return !target.hasSkill('zhenjiu2');
			},
			check:function(card){
				return 8-ai.get.value(card);
			},
			discard:false,
			prepare:'give',
			content:function(){
				target.storage.zhenjiu2=cards[0];
				game.addVideo('storage',target,['zhenjiu2',get.cardInfo(target.storage.zhenjiu2),'card']);
				target.addSkill('zhenjiu2');
			},
			ai:{
				result:{
					target:function(player,target){
						if(target.hp<target.maxHp){
							return target==player?1:1.5;
						}
						if(player.num('h')>player.hp) return 0.5;
						return 0;
					}
				},
				order:9,
				threaten:1.7
			}
		},
		zhenjiu2:{
			trigger:{player:'phaseBegin'},
			forced:true,
			mark:'card',
			content:function(){
				player.recover();
				player.gain(player.storage.zhenjiu2,'gain2','log');
				player.removeSkill('zhenjiu2');
				delete player.storage.zhenjiu2;
			},
			intro:{
				content:'card'
			}
		},
		shoulie:{
			trigger:{player:'shaBegin'},
			direct:true,
			content:function(){
				"step 0"
				var dis=trigger.target.num('h','shan')||trigger.target.num('e','bagua')||trigger.target.num('h')>2;
				var next=player.chooseToDiscard(get.prompt('shoulie',trigger.target));
				next.ai=function(card){
					if(dis) return 7-ai.get.value(card);
					return 0;
				}
				next.logSkill='shoulie';
				"step 1"
				if(result.bool){
					trigger.directHit=true;
				}
			}
		},
		hudun:{
			trigger:{source:'damageEnd'},
			forced:true,
			filter:function(event,player){
				return !player.hujia&&event.player!=player;
			},
			content:function(){
				player.changeHujia();
				player.update();
			},
		},
		toudan:{
			enable:'phaseUse',
			usable:1,
			filter:function(event,player){
				return player.num('he',{suit:'spade'});
			},
			filterTarget:function(card,player,target){
				return player!=target;
			},
			filterCard:{suit:'spade'},
			check:function(card){
				return 10-ai.get.value(card);
			},
			position:'he',
			line:'fire',
			content:function(){
				"step 0"
				target.damage('fire');
				event.targets=[];
				for(var i=0;i<game.players.length;i++){
					if(get.distance(target,game.players[i])<=1){
						event.targets.push(game.players[i]);
					}
				}
				get.sortSeat(event.targets,event.target);
				event.targets.unshift(player);
				"step 1"
				if(event.targets.length){
					var current=event.targets.shift();
					if(current.num('he')){
						current.chooseToDiscard('he',true);
					}
					event.redo();
				}
			},
			ai:{
				result:{
					target:function(player,target){
						return ai.get.damageEffect(target,player,target,'fire');
					}
				},
				order:10,
				threaten:1.5
			}
		},
		shending:{
			inherit:'longfan',
			filter:function(event,player){
				return !player.get('e','5');
			},
			ai:{
				order:11,
				result:{
					player:1,
				},
				effect:{
					target:function(card,player,target){
						if(player!=target) return;
						if(get.subtype(card)=='equip5'){
							if(ai.get.equipValue(card)<=7) return 0;
						}
					}
				},
				threaten:1.2
			}
		},
		poxiao:{
			mod:{
				attackFrom:function(from,to,distance){
					if(!from.get('e','1')) return distance-1;
				},
				selectTarget:function(card,player,range){
					if(!player.get('e','1')&&card.name=='sha') range[1]++;
				}
			},
			enable:'chooseToUse',
			filterCard:{type:'equip'},
			filter:function(event,player){
				return player.num('he',{type:'equip'});
			},
			position:'he',
			viewAs:{name:'sha'},
			prompt:'将一张闪当杀使用或打出',
			check:function(card){
				if(get.subtype(card)=='equip1') return 10-ai.get.value(card);
				return 7-ai.get.equipValue(card);
			},
			ai:{
				order:function(){
					return lib.card.sha.ai.order+0.1;
				},
				effect:{
					target:function(card,player){
						if(get.subtype(card)=='equip1'){
							var num=0;
							for(var i=0;i<game.players.length;i++){
								if(ai.get.attitude(player,game.players[i])<0){
									num++;
									if(num>1) return [0,0,0,0];
								}
							}
						}
					}
				}
			}
		},
	},
	translate:{
		swd_yangshuo:'杨硕',
		swd_septem:'赛特',
		swd_yuxiaoxue:'于小雪',
		swd_lilian:'莉莲',
		swd_cheyun:'车芸',
		swd_jipeng:'疾鹏',
		swd_muyun:'徐暮云',
		swd_zhaoyun:'皇甫朝云',
		swd_jiliang:'姬良',
		swd_lanyin:'兰茵',
		swd_zhiyin:'芝茵',
		swd_hengai:'横艾',
		swd_huzhongxian:'壶中仙',
		swd_qiner:'磬儿',
		swd_huanyuanzhi:'桓远之',
		swd_murongshi:'慕容诗',
		swd_hupo:'琥珀',
		swd_miles:'麦尔斯',
		swd_kangnalishi:'康那里士',
		swd_satan:'撒旦',
		swd_philis:'菲力斯',
		swd_weida:'薇达',
		swd_fengtianling:'凤天凌',
		swd_huyue:'瑚月',
		swd_jiting:'姬亭',
		swd_rongshuang:'蓉霜',
		swd_zhuoshanzhu:'浊山铸',
		swd_jialanduo:'迦兰多',
		swd_linming:'林明',
		swd_duanmeng:'端蒙',
		swd_nicole:'妮可',
		swd_kendi:'肯迪',
		swd_lijing:'李靖',
		swd_hanteng:'韩腾',
		swd_yuwentuo:'宇文拓',
		swd_shanxiaoxiao:'单小小',
		swd_yuchiyanhong:'尉迟嫣红',
		swd_pepin:'丕平',
		swd_anka:'安卡',
		swd_jiangwu:'疆梧',
		swd_situqiang:'司徒蔷',
		swd_tuwei:'徒维',
		swd_yeyaxi:'耶亚希',
		swd_chunyuheng:'淳于恒',
		swd_duguningke:'独孤宁珂',
		swd_duguningke2:'魔化宁珂',
		swd_chenjingchou:'陈靖仇',
		swd_zhanglie:'张烈',
		swd_guyue:'古月圣',
		swd_kama:'卡玛',
		swd_yuli:'玉澧',
		swd_duopeng:'多鹏',
		swd_jiangziya:'姜子牙',
		swd_heran:'何然',
		swd_zhanggao:'张诰',
		swd_hanlong:'韩龙',
		swd_jiuyou:'久悠',
		swd_qingming:'青冥',
		swd_shangzhang:'尚章',
		swd_youzhao:'游兆',
		swd_wangsiyue:'王思月',
		swd_huanglei:'黄雷',
		swd_tuobayuer:'拓跋玉儿',
		swd_tuobayueer:'拓跋月儿',
		swd_chengyaojin:'程咬金',
		swd_qinshubao:'秦叔宝',
		swd_lishimin:'李世民',
		swd_shuijing:'水镜',
		swd_xuanyuanjianxian:'轩辕剑仙',
		swd_xuanyuanjiantong:'轩辕剑童',
		swd_luchengxuan:'陆承轩',
		swd_xiarou:'夏柔',
		swd_moye:'莫邪',
		swd_fu:'毛民·福',
		swd_hanluo:'寒洛',
		swd_linyue:'临月',
		swd_zidashu:'子大暑',
		swd_maixing:'麦星',
		swd_haidapang:'海大胖',
		swd_shaowei:'少微',
		swd_fuyan:'符验',
		swd_huiyan:'慧彦',
		swd_sikongyu:'司空宇',
		swd_muyue:'沐月',
		swd_ziqiao:'子巧',
		swd_fengyu:'凤煜',
		swd_qi:'柒',
		swd_chenfu:'陈辅',
		swd_libai:'李白',
		swd_xingtian:'刑天',
		swd_lanmoshen:'蓝魔神',
		swd_wushi:'巫师',
		swd_quxian:'屈娴',
		swd_xiyan:'犀衍',

		shenyan:'神炎',
		shenyan_info:'限定技，当你即将造成火焰伤害时，你可以令此伤害+1，并对目标距离1以内的所有其他角色各造成一点火焰伤害',
		xuanying:'旋影',
		xuanying_info:'你可以横置你的武将牌，视为使用一张无视距离的杀；每当你于回合外失去牌，你可以竖置你的武将牌，视为使用一张无视距离的杀',
		wendao:'问道',
		wendao_info:'每当你于回合外使用或打出一张牌，你可以令当前回合角色弃置一张与之花色相同的牌，否则你获得其一张牌',
		lingfeng:'凌锋',
		lingfeng_info:'回合结束阶段，若你本回合内使用了至少X张牌，你可以选择一项：获得一点护甲，或对攻击范围内的一名角色造成一点伤害（X为你当前的体力值且最多为3）',
		hxunzhi:'殉志',
		hxunzhi_info:'限定技，出牌阶段，你可以视为使用一张万箭齐发并获得技能武圣、咆哮，若如此做，你在此阶段结束时死亡',
		lmazui:'麻醉',
		lmazui2:'麻醉',
		lmazui_info:'出牌阶段限一次，你可以将一张黑色手牌置于一名角色的武将牌上，该角色造成的下一次伤害-1，然后获得此牌',
		hyunshen:'云身',
		hyunshen2:'云身',
		hyunshen_info:'每当你打出一张闪，你可以令其他角色与你的距离+1；回合开始阶段，你将累计的防御距离清零，然后摸等量的牌',
		hlingbo:'凌波',
		hlingbo_info:'每当你使用或打出一张闪，你可以摸两张牌',
		gtiandao:'天道',
		gtiandao_info:'任意一名角色的判定生效前，你可以打出一张牌替换之',
		nlianji:'连计',
		nlianji_info:'出牌阶段限一次，你可以选择一张手牌并指定两名角色进行拼点，拼点赢的角色获得此牌，并对没赢的角色造成一点伤害',
		fengze:'风泽',
		fengze_info:'出牌阶段限一次，你可以将一张黑色牌当作桃园结义使用',
		lingyue:'凌月',
		lingyue_info:'每当你使用一张杀，你可以令目标弃置一张牌',
		jinlin:'金鳞',
		jinlin_info:'限定技，出牌阶段，你可以令任意名角色各获得3点护甲，获得护甲的角色于每个回合开始阶段失去1点护甲直到首次失去所有护甲或累计以此法失去3点护甲',
		huanxia:'幻霞',
		huanxia_info:'你可以将一张红色牌当作杀使用，若此杀未造成伤害，你在回合结束时收回此牌',
		jingjie:'幻镜',
		jingjie_info:'回合开始阶段，你可以流失一点体力，并',
		jingjie_old_info:'限定技，出牌阶段，你可以令所有角色弃置所有牌，然后摸两张牌（不触发任何技能）',
		kongmo:'恐魔',
		kongmo_info:'锁定技，你使用基本牌或非延时锦囊牌后将额外结算一次卡牌效果',
		jufu:'巨斧',
		jufu_info:'锁定技，当你有武器牌时，杀造成的伤害+1',
		huajing:'化精',
		huajing_info:'每当你使用锦囊牌造成伤害，可以回复一点体力并摸一张牌',
		pingxu:'冯虚',
		pingxu_info:'锁定技，当你没有武器牌时，与其他角色的距离-1；当你没有防具牌时，其他角色与你的距离+1',
		yudun:'愚钝',
		yudun_info:'锁定技，你无法使用锦囊牌；你可以将两张锦囊牌当作一张不计入出杀次数的杀使用',
		bingfeng:'冰封',
		bingfeng2:'冰封',
		bingfeng2_info:'不能使用或打出手牌',
		bingfeng_info:'限定技，出牌阶段，你可以指定至多三个目标与其一同翻面，且处于翻面状态时不能使用或打出手牌；若如此做，你失去技能玄咒并减少一点体力上限',
		guozao:'聒噪',
		guozao_info:'锁定技，每当距离你1以内的角色受到一次伤害，若伤害来源不你，你须观看牌堆顶的三张牌，然后指定距离2以内的一名有手牌角色将手牌与这些牌交换',
		heihuo:'黑火',
		heihuo_info:'出牌阶段，你可以弃置一张装备牌，令你的手牌数加倍；若你的手牌因此达到8张或更多，你立即受到3点火焰伤害且本回合内不能再次发动黑火',
		yaotong:'妖瞳',
		yaotong1:'妖瞳',
		yaotong2:'妖瞳',
		yaotong3:'妖瞳',
		yaotong4:'妖瞳',
		yaotong_info:'当你的手牌数为奇数时，你可以将一张手牌当作杀或闪使用或打出，当你的手牌数为偶数时，你可以将一张手牌当作无懈可击使用',
		pojian:'破茧',
		pojian_info:'每当你失去最后一张手牌，可以从牌堆中获得一张装备牌并装备之',
		huajin:'化金',
		huajin2:'化金',
		huajin_info:'出牌阶段限一次，你可以弃置一张牌令你造成的伤害+1，直到你的下一回合开始',
		poxiao:'破霄',
		poxiao_info:'你可以将一张装备牌当杀使用；当你没有武器牌时，你的攻击范围+1，杀可以额外指定一个目标',
		jianji:'箭疾',
		jianji_info:'你可以将一张装备牌当杀使用，然后摸一张牌，此杀无视距离和防具，且不计入回合内出杀限制',
		yuchen:'浴尘',
		yuchen_info:'每当你于回合外使用或打出一张黑色牌，你可以弃置一名角色的一张牌',
		huangyu:'凰羽',
		huangyu_info:'出牌阶段限一次，你可以将两张红色牌当炽羽袭使用',
		bingjian:'冰箭',
		bingjian_info:'出牌阶段限一次，你可以弃置一张黑色的杀，令一名有手牌的其他角色展示手牌并弃置其中的所有闪，若其没有闪则受到一点雷电伤害',
		rumeng:'入梦',
		rumeng_info:'其他角色的出牌阶段前，你可以弃置一张非基本牌，并令其选择一项：弃置一张基本牌，或跳过出牌及弃牌阶段',
		lianda:'连打',
		lianda_info:'当你使用一杀结算完毕后，可以弃置一张牌视为对目标再使用一张杀',
		xianghui:'祥晖',
		xianghui_info:'出牌阶段限一次，你可以弃置一张红色手牌，然后令场上体力值最少的角色各回复一点体力',
		huiqi:'回气',
		huiqi_info:'每当你受到一次伤害，可令一名其他角色摸X张牌，X为你已损失的体力值',
		toudan:'投弹',
		toudan_info:'出牌阶段限一次，你可以弃置一张黑桃牌对一名其他角色造成一点火焰伤害，然后你与距离该角色1以内的所有角色各弃置一张牌',
		shending:'神丁',
		shending_info:'锁定技，若你没有宝物牌，视为装备了蓝格怪衣',
		hzhenwei:'镇卫',
		hzhenwei_info:'当一名其他角色成为杀的目标后，若你在杀的使用者的攻击范围内，你可以弃置一张牌将此杀转移给自己，并在杀结算完毕后摸一张牌',
		shoulie:'狩猎',
		shoulie_info:'当你使用一张杀指定目标后，可以弃置一张手牌令此杀不可闪避',
		hudun:'盾甲',
		hudun_bg:'盾',
		hudun2:'盾甲',
		hudun_info:'锁定技，当你对其他角色造成伤害后，若你没有护甲，你获得一点护甲值',
		zhenjiu:'针灸',
		zhenjiu2:'针灸',
		zhenjiu_info:'出牌阶段限一次，你可以将一张红色手牌置于一名角色的武将牌上，该角色于下一个回合开始阶段回复一点体力，然后获得此牌',
		ljifeng:'疾风',
		ljifeng_info:'锁定技，你的攻击范围+X，杀可以额外指定X个目标，X为你已损失的体力值',
		lxianglong_info:'每当你闪避一张杀，可以将此杀对攻击范围内的一名角色使用',
		lxianglong:'翔龙',
		shangxi:'伤袭',
		shangxi_info:'回合开始阶段，你可以弃置一张牌，并对攻击范围内一名体力值不小于你的其他角色造成一点伤害',
		fzhenwei:'镇威',
		fzhenwei_info:'在你的回合内，你可以将其他角色打出的卡牌交给除该角色外的任意一名角色',
		fuyan:'覆岩',
		fuyan2:'覆岩',
		fuyan_info:'每当你受到一次伤害，可以令一名没有护甲的角色获得一点护甲值',
		guaili:'怪力',
		guaili_info:'锁定技，你的杀造成的伤害+1，造成伤害后需弃置两张手牌',
		pingshen:'凭神',
		pingshen2:'凭神',
		pingshen_info:'锁定技，受到过你的伤害的角色可在回合内对你发动一次【离魂】（每局限发动一次）',
		xingzhui:'星坠',
		xingzhui_info:'出牌阶段限一次，你可以弃置一张牌，并令一名角色弃置一张类别相同的牌，若则受到一点伤害',
		lingxian:'凌仙',
		lingxian_info:'每当你于回合外使用或打出一张手牌，你可以选择攻击范围外的一名其他角色与你各摸一张牌',
		shouyin:'守印',
		shouyin_info:'限定技，当任意一名角色处于濒死状态时，若你的武将牌正朝上，可以将武将牌翻面，然后令场上所有存活角色将体力回复至体力上限',
		bofeng:'搏风',
		bofeng_info:'锁定技，体力值不大于你的角色视为在你的攻击范围；当你使用杀指定目标时，可令目标额外打出一张闪，否则此杀不可闪避且造成的伤害+1',
		hutian:'护天',
		hutian2:'护天',
		hutian3:'护天',
		hutian_info:'回合结束阶段，你可以将X张牌置于一名角色的武将牌上，则该角色的体力值始终不能小于X；在你的下一个回合结束阶段，该角色获得武将牌上的牌（在此回合不能再次发动）',
		linyun:'凌云',
		linyun_info:'你可以将两张牌当作杀使用，此杀需要额外一张闪才能闪避',
		sliufeng:'流风',
		sliufeng_info:'锁定技，体力值不大于你的角色视为在你的攻击范围',
		chengjian:'承剑',
		chengjian_info:'每当其他角色使用杀造成一次伤害，你可以令其摸一张牌',
		huanling:'幻灵',
		huanling2:'幻灵',
		huanling_info:'回合结束阶段，你可以选择一名角色与你同时翻面；翻面状态下，你防止一切伤害',
		xiaozhan:'消战',
		xiaozhan_info:'其他角色使用杀时，若你不是杀的目标，可以弃置一张杀取消之',
		xielei:'挟雷',
		xielei_info:'每当你使用或打出一张杀，可以弃置一张牌并对目标以外的一名角色造成一点雷电伤害',
		dangping:'荡平',
		dangping_info:'每当你造成一次伤害，可以弃置一张手牌对其距离1以内的另一名角色造成一点伤害，每回合限一次',
		guisi:'归思',
		guisi_info:'每当你成为杀的目标，你可以交给对方一张手牌并取消之',
		duishi:'对诗',
		duishi_info:'出牌阶段，你可以弃置一张手牌，并指定一名有手牌的角色选择一项：1)弃置一张与之花色相同的手牌，本回合内对诗不能再次指定其为目标，2)令你获得其一张牌，对诗失效直到回合结束',
		anlianying:'连营',
		anlianying_info:'每当你失去最后一张手牌，可摸两张牌',
		lianwu:'连舞',
		lianwu_info:'锁定技，你的杀可以额外指定一个目标，你的红杀不可被闪避',
		jiying:'疾鹰',
		jiying_info:'锁定技，你使用杀无视距离',
		daofa:'道法',
		daofa_info:'每当有一名其他角色造成伤害，你可以令其弃置一张牌',
		xiaomoyu:'魔愈',
		xiaomoyu_info:'锁定技，每当你于一个回合内首次造成伤害，你回复一点体力，若你没有受伤，则改为摸一张牌',
		yihua:'移花',
		yihua_info:'每当你成为其他角色的某张卡牌的惟一目标时，你可以弃置两张手牌，将使用者与目标对调',
		youyin:'游吟',
		youyin_info:'每当有其他角色弃置卡牌时，若其中有非基本牌且你的手牌数不超过5，你可以摸一张牌',
		rexue:'热血',
		rexue_info:'任意一名角色的回合开始阶段，你可以对其使用一张杀，然后摸一张牌',
		huopu:'火瀑',
		huopu_info:'出牌阶段限一次，你可以将一张红桃牌当作流星火羽使用',
		benlei:'奔雷',
		benlei2:'奔雷',
		benlei_info:'你可以将三张牌当惊雷闪使用；每当你造成一次雷属性伤害，你回复一点体力',
		lingwu:'灵舞',
		lingwu_info:'回合结束后，若你在本回合内使用的牌数不少于当前体力值，你可以进行一个额外的回合（不可重复发动）',
		miejing:'灭境',
		miejing_info:'限制技，你可以弃置所有黑色牌，然后令所有其他角色受到一点雷电伤害',
		lingxin:'灵心',
		lingxin_info:'回合结束阶段，你可以亮出牌堆顶的三张牌，然后获得其中的红桃牌',
		fushen:'附身',
		fushen_info:'回合开始前，你可以将自己移出游戏，并代替另一名角色进行一回合，然后流失一点体力',
		fushen2:'附身',
		wangchen:'忘尘',
		wangchen_info:'若你于弃牌阶段弃置了基本牌，可令一名角色翻面',
		guiyin:'归隐',
		guiyin_info:'若你于弃牌阶段弃置了至少两张牌，你可以摸两张牌',
		shejie:'设界',
		shejie2:'设界',
		shejie_info:'每当你受到一次伤害，可以令伤害来源不能使用或打出其手牌，直到其下一回合开始',
		shejie2_info:'不能使用或打出手牌，直到下一回合开始',
		yinyue:'引月',
		yinyue_info:'每当有一名角色回复一次体力，你可以令其摸一张牌，若你的手牌数不大于该角色，你也摸一张牌',
		mohua2:'魔化',
		mohua2_info:'锁定技，当你进入濒死状态时，你立即变身为撒旦，将体力回复至２，然后摸两张牌',
		liexin:'裂心',
		liexin_info:'每当你即将造成伤害，你可以弃置一张牌令伤害+1',
		swdxueyi:'血裔',
		swdxueyi_info:'锁定技，你摸牌阶段额外摸X张牌，X为你已损失的体力值',
		moyan:'血焰',
		moyan_info:'出牌阶段，你可以弃置X张红色手牌，然后对至多X名角色各造成一点火焰伤害，X为你已损失的体力值。每阶段限一次',
		aojian:'傲剑',
		aojian_info:'出牌阶段，你可以弃置X张手牌，然后对攻击范围内至多X名角色各造成一点伤害，X为你已损失的体力值。每阶段限一次',
		milesxiehun:'邪魂',
		milesxiehun_info:'锁定技，出牌阶段结束后，你令随机Ｘ名角色各弃置一张牌，Ｘ为你已损失的体力值且至少为1 ',
		liaochen:'撩尘',
		liaochen_info:'锁定技，出牌阶段结束后，所有角色需弃置一张牌',
		yinmo:'引魔',
		yinmo_info:'锁定技，当你对场上所有角色发动「连计」后，你立即变身为魔化宁珂，然后对所有其他角色造成一点雷电伤害',
		huanxing:'幻形',
		huanxing2:'幻形',
		huanxing_info:'回合开始阶段，你可以弃置一张牌并选择一名男性角色，获得其所有技能，直到你首次受到伤害',
		meihuo:'魅惑',
		meihuo_info:'每当你失去最后一张装备牌，你可以获得一名其他角色的一张牌，若此牌来自装备区，你立即装备之',

		touxi:'偷袭',
		touxi_info:'在其他角色的回合结束阶段，你可以进行一次判定，若结果为黑色，你对其造成一点雷电伤害，且直到下一回合开始不能再次发动偷袭；若结果为红色，对方可以弃置你的一张牌',
		minjing:'明镜',
		minjing_info:'若你没有防具牌，你视为装备了光纱天衣',
		jqimou:'奇谋',
		jqimou_info:'每当你于回合外受到一次伤害，你可以摸一张牌，并立即使用之',
		mufeng:'沐风',
		mufeng_info:'在一名角色的回合结束阶段，若你的手牌数比其少，你可以将手牌补至与该角色相同（最多补至5），每轮限一次',
		hjifeng:'祭风',
		hjifeng_info:'回合结束阶段，若你手牌中没有祭器牌，你可以弃置一张装备区内的牌，并从牌堆中获得一张随机祭器',
		mufeng_old_info:'锁定技，每当你于回合外失去牌，你的防御距离+1；若防御距离的变化值超过了存活角色数的一半，则降至0',
		lexue:'乐学',
		lexue_info:'回合内，你随机获得制衡、集智、缔盟、驱虎中的一个技能；回合外，你随机获得遗计、急救、鬼道、反馈中的一个技能',
		mingfu:'冥缚',
		mingfu_info:'出牌阶段限一次，你可以将一张梅花牌当鬼幽结使用',
		chuanyue:'穿月',
		chuanyue_info:'出牌阶段限一次，你可以将两张手牌当决斗使用',

		miedao:'灭道',
		miedao1:'灭道',
		miedao2:'灭道',
		miedao_info:'锁定技，摸牌阶段，你额外摸X张牌；弃牌阶段，你至少须弃X张牌（不足则全弃），X为你已损失的体力值。',

		senluo:'森罗',
		senluo_info:'出牌阶段限一次，若你的手牌数为全场最少或之一，你可以令所有有手牌的其他角色摸一张牌并弃置两张手牌',
		polang:'破浪',
		polang_info:'每当你造成一次伤害，可以一张对方的装备牌',
		jikong:'亟空',
		jikong2:'亟空',
		jikong_info:'当你失去最后一张手牌，或在回合开始阶段时，你可以指定一名角色视为对其使用一张雷杀',
		xiangu:'仙骨',
		xiangu_info:'锁定技，你的手牌上限不会因体力值的减少而减少。',
		yiesheng:'回雪',
		yiesheng_info:'出牌阶段，你可以弃置任意数量的黑色手牌，然后摸等量的牌。',
		huajian:'化剑',
		huajian_info:'出牌阶段结束时，你可以弃置一张牌，视为对一张角色使用一张杀',
		xuanyuan:'轩辕',
		xuanyuan_info:'锁定技，你无视轩辕剑的装备条件；失去轩辕剑时不流失体力',
		jilve:'极略',
		jilve2:'极略',
		jilve_info:'回合内，你可以观看牌堆顶的两张牌，然后使用其中的基本牌或锦囊牌。每回合最多发动三次',
		gongshen:'工神',
		gongshen_info:'任意一名其他角色使用一张基本牌或锦囊牌指定目标后，你可以弃置一张装备牌令其失效',

		liuhong:'流虹',
		liuhong_info:'每当你使用一张杀，可以摸一张牌',
		poyue:'破月',
		poyue_info:'锁定技，你的黑杀无视距离，红色不计入回合内的出杀限制且不可闪避',
		mojian:'墨剑',
		mojian_info:'每当你使用杀并指定目标后，你可以令其摸一张牌，然后你回复一点体力',
		duanyue:'断月',
		duanyue_info:'出牌阶段限一次，你可以弃置一张装备牌，对一名其他角色造成一点伤害，并弃其所有手牌。若弃置的手牌数有两张或更多，你流失一点体力',
		fengmo:'封魔',
		fengmo_info:'出牌阶段限一次，你可以弃置场所有武器牌（至少两张），然后令一名未翻面的角色摸等量的牌并翻面',
		pozhou:'破咒',
		pozhou_bg:'破',
		pozhou2:'破咒',
		pozhou_info:'每当你受到一次伤害，你获得一枚破咒标记。出牌阶段，你可以指定任意名其他角色并弃置等量的破咒标记，令目标的非锁定技失效直到其下一回合结束',
		xuanzhou:'玄咒',
		xuanzhou_info:'出牌阶段限一次，你可以将一张非延时锦囊牌当作任意一张延时锦囊，对任意一名角色使用（无视锦囊使用范围限制）',
		ningxian:'凝霰',
		ningxian_info:'每当你受到一次伤害，你可以弃置任意张黑色牌并选择等量其他角色对其各造成一点伤害',
		guanhu:'贯鹄',
		guanhu_info:'每当你使用杀造成伤害，你可以弃置对方一张牌',
		chuanyang:'穿杨',
		chuanyang_info:'每当你使用一张杀，若你不在目标的攻击范围，你可以令此杀不可闪避',
		fengming:'凤鸣',
		fengming_info:'出牌阶段限一次，你可以弃置一张装备牌，令一名角色恢复一点体力并摸一张牌',
		duanxing:'锻星',
		duanxing_info:'每当你装备一张未强化的装备牌，可以视为一名角色使用一张杀',
		wanjun:'万钧',
		wanjun_info:'你可以将一张装备牌当作南蛮入侵使用',
		dunxing:'遁形',
		// dunxing_info:'锁定技，体力值比你多的角色无法在回合内对你使用卡牌',
		guiying:'鬼影',
		guiying_info:'你可以将一张黑色牌当偷梁换柱使用',
		shehun:'摄魂',
		shehun_info:'出牌阶段限一次，你可以弃置任意张花色不同的牌，另一名其他角色弃置等量的牌，若其弃置的牌中有牌的花色与你弃置的牌相同，你对其造成一点伤害',


		zhanlu:'沾露',
		luomu:'落木',
		jifeng:'魔影',
		liaoyuan:'燎原',
		huanhun:'唤魂',
		daixing:'代形',
		yishan:'异闪',
		yishan2:'异闪',
		swd_wuxie:'无邪',
		qingcheng:'倾城',
		xianjiang:'仙匠',
		xianjiang3:'仙匠',
		shengong:'神工',
		ningjian:'凝剑',
		ningjian1:'凝剑',
		ningjian2:'凝剑',
		taixu:'太虚',
		duoren:'夺刃',
		tanlin:'探麟',
		tanlin2:'探麟',
		pozhen:'破阵',
		yunchou:'运筹',
        tianshu:'天书',
		tianshu_bg:'书',
		tianshu2:'天书',
		xingdian:'星点',
		luomei:'落梅',
		yulin:'玉鳞',
		funiao:'符鸟',
		xuehuang:'血凰',
		zhuyu:'朱羽',
		ningshuang:'凝霜',
		zaowu:'造物',
		// shouhua:'收化',
		xielv:'谐率',
		tianhuo:'天火',
		huanyin:'幻音',
		tianlun:'天轮',
		hlongyin:'龙吟',
		lanzhi:'兰芷',
		duanyi:'断意',
		miesheng:'灭生',
		guxing:'孤星',
		guxing1:'孤星',
		guxing2:'孤星',
		poxing:'破星',
		mohua:'魔化',
		miles_xueyi:'血裔',
		wuying:'无影',
		xiehun:'邪魂',
		xiehun1:'邪魂',
		xiehun2:'邪魂',
		xiehun3:'邪魂',
		jumo:'聚魔',
		duijue:'对决',
		duijue_bg:'决',
		yueren:'月刃',
		busi:'不死',
		xuying:'虚影',
		yinguo:'因果',
		guiyan:'鬼眼',
		guiyan2:'鬼眼',
		swd_xiuluo:'修罗',
		suiyan:'碎岩',
		suiyan_info:'每当你造成一次伤害，可以弃置一张牌并弃置对方的全部装备牌',
		xianyin:'散结',
		qiaoxie:'巧械',
		qiaoxie2:'巧械',
		qiaoxie3:'巧械',
		qiaoxie4:'巧械',
		mailun:'脉轮',
		mailun31:'脉轮',
		mailun32:'脉轮',
		mailun41:'脉轮',
		mailun42:'脉轮',
		kunlunjing:'幻镜',
		kunlunjing1:'幻镜',
		kunlunjing2:'幻镜',
		susheng:'苏生',
		shengshou:'圣手',
		huanjian:'幻箭',
		yuhuo:'浴火',
		huanjian_info:'你可以将一张黑色牌当作冰魄筒使用',
		shengshou_info:'你可以将一张黑色手牌当作草药使用',
		susheng_info:'在任意一名角色即将死亡时，你可以弃置一张手牌防止其死亡，并将其体力回复至1，每回合限发动一次',
		zhanlu_info:'出牌阶段，你可以弃置一张黑桃牌令至多３名角色各回复一点体力',
		kunlunjing_info:'回合开始阶段，若你的体力值小于上回合结束时的体力值，你可以将场上所有牌还原到你上一回合结束时的位置',
		swd_xiuluo_info:'回合开始阶段，你可以弃一张手牌来弃置你判断区里的一张延时类锦囊（必须花色相同）',
		xianyin_info:'出牌阶段，你可以令所有判定区内有牌的角色弃置判定区内的牌，然后交给你一张手牌',
		qiaoxie_info:'每当你装备一张牌，可摸一张牌；每当你失去一张装备牌（不含替换），你可以弃置其他角色的一张牌',
		mailun_info:'回合开始阶段，你可以选择一个脉轮效果直到下一回合开始',
		guiyan_info:'出牌阶段，你可以观看一名角色的手牌，并获得其中一张梅花牌，每阶段限一次。当你首次进入濒死状态时，你须回复一点体力并失去技能鬼眼',
		busi_info:'锁定技，当你进入濒死状态时，你进行一次判定，若结果不为黑桃，你将体力回复至1并将武将牌翻至背面',
		xuying_info:'锁定技，每当你即将受到伤害，你防止此伤害，若你此时有手牌，你流失一点体力',
		yinguo_info:'除你之外的任意一名角色即将受到受到伤害时，若有伤害来源，你可以弃置一张牌将伤害来源和目标对调',
		yueren_info:'每当你使用一张杀，可以进行一次判定，若结果为黑色，你弃置目标一张牌，若结果为红色，你将此杀收回，每回合限发动一次',
		duijue_info:'限定技，出牌阶段，你可以指定一名非主公的其他角色，你结束出牌阶段，然后该角色与你轮流进行回合，直到一方死亡为止；在此之前，所有其他角色不计入距离的计算且不能使用牌且不是牌的合法目标',
		wuying_info:'锁定技，你的杀和单体x锦囊目标锁定为范围内的所有角色',
		xiehun_info:'锁定技，受到来自你伤害的角色进入混乱状态，行为不受控制，且会攻击队友，直到你的下一回合开始',
		jumo_info:'锁定技，回合结束阶段，你摸X-1张牌，X为未进入混乱状态的角色数与进入混乱状态的角色数之差（若为双将则改为X）',
		jifeng_info:'你的杀和单体锦囊可以额外指定任意个目标，若如此做，此卡牌有一定机率失效，指定的目标越多失效的概率越大',
		mohua_info:'锁定技，在身份局中，当你进入濒死状态时，你立即变身为撒旦，体力上限变为现存角色数（至少为4），并成为其他所有角色的共同敌人',
		miles_xueyi_info:'锁定技，你防止即将受到的伤害，然后流失一点体力',
		duanyi_info:'出牌阶段限一次，你可以弃置两张杀，对一名角色造成一点伤害，然后其随机弃置X张牌，X为其已损失的体力值',
		guxing_info:'出牌阶段，你可以将最后至多X张手牌当杀使用，此杀无视距离且可以指定至多3个目标，每造成一次伤害，你摸一张牌，Ｘ为你已损失的体力值且至少为１。',
		tianlun_info:'任意一名角色的判定生效前，你可以弃置一张场上角色的判定牌代替之',
		hlongyin_info:'出牌阶段，你可以弃置任意张颜色相同且点数不同的牌，并获得逆时针座位距离与卡牌点数相同的角色区域内的一张牌。每阶段限一次',
		lanzhi_info:'每当你使用一张梅花牌，你可以令所有体力值不大于你的角色回复一点体力',
		lanzhi_old_info:'每当你即将造成伤害，可以防止此伤害，然后摸两张牌。每回合限发动一次。',
		tianhuo_info:'出牌阶段，你可以令所有角色弃置其判定区域内的牌，并受到没有来源的等量火焰伤害，每阶段限一次',
		huanyin_info:'锁定技，每当你成为其他角色的卡牌的目标时，你进行一次判定，若为黑桃则取消之，若为红桃你摸一张牌',
		luomu_info:'锁定技，每当你造成伤害时，受伤害角色随机弃置一张牌',
		poxing_info:'锁定技，每当你即将造成伤害，若目标的体力值大于你，你令伤害+1',
		liaoyuan_info:'每当你使用一张杀指定目标后，你可以弃置任意张与此杀花色相同的牌，若如此做，目标需额外打出等量的闪，每少打出一张闪，此杀的伤害+1',
		yuhuo_info:'限定技，濒死阶段，你可以重置角色牌，减少一点体力上限，然后将体力回复至体力上限',
		yishan_info:'每当你受到一次伤害，你可以重新获得最近失去的两张牌',
		huanhun_info:'当一名角色进入濒死状态时，你可以弃置一张红色牌并令其进行一次判定，若结果为红色，其回复一点体力',
		daixing_info:'回合结束阶段，你可以任意张牌并获得等量的护甲，这些护甲将在你的下个回合开始阶段消失',
		swd_wuxie_info:'锁定技，你不能成为其他角色的延时锦囊的目标',
		qingcheng_info:'回合结束阶段，你可以进行判定，若为红色则可以继续判定，最多判定3次，判定结束后将判定成功的牌收入手牌',
		xianjiang_old_info:'出牌阶段，你可以将一张装备牌永久转化为任意一张其它装备牌，一张牌在一个阶段只能转化一次',
		xianjiang_info:'出牌阶段限一次，你可以弃置一张锦囊牌并随机装备一件装备',
		shengong_info:'每当你需要打出一张杀或闪时，你可以弃置一名其他角色装备区内的一张武器牌或防具牌，视为打出一张杀或闪，然后该角色摸一张牌，你弃一张牌',
		ningjian_info:'你可以将一张红色牌当闪、黑色牌当杀使用或打出',
		taixu_info:'限定技，你可以弃置你的所有牌（至少1张），并对一名体力值大于1为其他角色造成X点火焰伤害，X为你已损失的体力值且至少为1',
		duoren_info:'每当你闪避一张杀，你可以立即获得来源的武器牌',
		tanlin_info:'出牌阶段限一次，你可以与一名其他角色进行拼点，若你赢，你获得对方拼点牌、对该角色使用卡牌无视距离且可以额外使用一张杀直到回合结束，若你没赢，你受到该角色的一点伤害。',
		pozhen_info:'每当你受到一次伤害，若你的手牌数大于伤害来源，你可以弃置X张手牌对其造成一点伤害；若你的手牌数小于伤害来源，你可以弃置其X张手牌。X为你与伤害来源的手牌数之差。',
		yunchou_info:'出牌阶段限一次，你可以弃置任意张手牌，并弃置一张其他角色的手牌，你弃置的手牌中每有一张与此牌的颜色相同，你摸一张牌，否则对方摸一张牌',
		tianshu_old_info:'回合结束阶段，你可以弃置一张牌并从三名随机武将中选择一个，在2X回合后你将其所有技能加入你的天书列表，X为其技能数；在技能加入天书列表时，或于出牌阶段，你可以装备一项天书列表中的技能',
		tianshu_info:'出牌阶段，你可以交给一名其他角色一张锦囊牌，然后获得该角色的一项技能直到该角色死亡（替换以此法获得的前一个技能）',
		zaowu_info:'出牌阶段限一次，你可以将一张黑桃牌当作封印之蛋使用',
		luomei_info:'每当你使用或打出一张梅花花色的牌，你可以摸一张牌',
		xingdian_info:'出牌阶段限一次，你可以弃置一张手牌，然后指定至多两名角色令其各弃置一张牌',
		yulin_info:'每当你即将受到伤害，你可以弃置一张装备牌抵消此伤害',
		funiao_info:'出牌阶段，你可以交给一名角色一张手牌，然后观看其手牌，每个阶段对一名角色只能发动一次',
		xuehuang_info:'出牌阶段限一次，你可以弃置一张红色手牌令距离你一以内的所有角色受到一点火焰伤害',
		zhuyu_info:'每当有横置的角色即将受到非火焰伤害，你可以弃置一张红色牌使其额外受到一点火焰伤害',
		ningshuang_info:'每当你成为黑色牌的目标，你可以弃置一张黑色牌将其横置，并摸一张牌，若其已经模置则改为将其翻面',
		zaowu_old_info:'出牌阶段，你可以弃置三张不同类型的牌，创造任意两张牌并获得之',
		xielv_info:'弃牌阶段结束后，若你的所有手牌（至少两张）颜色均相同，你可以展示所有手牌，然后选择一项：1、回复一点体力；2、弃置场上所有与你手牌颜色不同的牌',
	},
}