x

card/standard.js

@@ -1205,7 +1205,10 @@ card.standard={
 			viewAs:{name:'sha'},
 			audio:true,
 			prompt:'将两张手牌当杀使用或打出',
-			check:function(card){return 6-ai.get.useful(card)},
+			check:function(card){
+				if(card.name=='sha') return 0;
+				return 6-ai.get.useful(card)
+			},
 			ai:{
 				respondSha:true,
 			}

character/boss.js

@@ -1,6 +1,5 @@
 'usr strict';
 character.boss={
-	mode:['identity','guozhan','stone','boss'],
 	character:{
 		boss_zhangchunhua:['female','wei',4,['jueqing','wuxin','shangshix'],['boss','bossallowed'],'wei'],
 		boss_zhenji:['female','wei',4,['tashui','lingbo','jiaoxia','fanghua'],['boss','bossallowed'],'wei'],
@@ -34,8 +33,136 @@ character.boss={
 		boss_dongzhuo:['male','qun',20,['jiuchi','boss_qiangzheng','boss_baolin'],['boss','bossallowed'],'shu'],
 		// boss_shuijing:['male','qun',8,[],['boss','bossallowed'],'wei'],
 
+		boss_liedixuande:['male','shu',5,[],['jiangeboss','hiddenboss','bossallowed'],'shu'],
+		boss_gongshenyueying:['male','shu',4,[],['jiangeboss','hiddenboss','bossallowed'],'shu'],
+		boss_tianhoukongming:['male','shu',4,[],['jiangeboss','hiddenboss','bossallowed'],'shu'],
+		boss_yuhuoshiyuan:['male','shu',4,[],['jiangeboss','hiddenboss','bossallowed'],'shu'],
+		boss_qiaokuijunyi:['male','wei',4,[],['jiangeboss','hiddenboss','bossallowed'],'wei'],
+		boss_jiarenzidan:['male','wei',5,['boss_chiying','boss_jingfan'],['jiangeboss','hiddenboss','bossallowed'],'wei'],
+		boss_duanyuzhongda:['male','wei',5,['boss_fanshi','boss_xuanlei','boss_skonghun'],['jiangeboss','hiddenboss','bossallowed'],'wei'],
+		boss_juechenmiaocai:['male','wei',4,['boss_chuanyun','boss_leili','boss_fengxing'],['jiangeboss','hiddenboss','bossallowed'],'wei'],
+
+		boss_baihumech:['male','shu',4,[],['jiangemech','hiddenboss','bossallowed'],'shu'],
+		boss_qinglongmech:['male','shu',4,[],['jiangemech','hiddenboss','bossallowed'],'shu'],
+		boss_xuanwumech:['male','shu',4,[],['jiangemech','hiddenboss','bossallowed'],'shu'],
+		boss_zhuquemech:['male','shu',4,[],['jiangemech','hiddenboss','bossallowed'],'shu'],
+		boss_bianmech:['male','wei',4,[],['jiangemech','hiddenboss','bossallowed'],'wei'],
+		boss_chiwenmech:['male','wei',4,[],['jiangemech','hiddenboss','bossallowed'],'wei'],
+		boss_suannimech:['male','wei',4,[],['jiangemech','hiddenboss','bossallowed'],'wei'],
+		boss_yazimech:['male','wei',4,[],['jiangemech','hiddenboss','bossallowed'],'wei'],
+
 	},
 	skill:{
+		boss_xuanlei:{
+            trigger:{player:'phaseBegin'},
+            forced:true,
+            filter:function(event,player){
+                for(var i=0;i<game.players.length;i++){
+					if(typeof player.side=='boolean'&&player.side==game.players[i].side) continue;
+                    if(game.players[i]!=player&&game.players[i].num('j')) return true;
+                }
+                return false;
+            },
+            content:function(){
+                "step 0"
+                event.targets=[];
+                for(var i=0;i<game.players.length;i++){
+					if(typeof player.side=='boolean'&&player.side==game.players[i].side) continue;
+                    if(game.players[i]!=player&&game.players[i].num('j')){
+                        event.targets.push(game.players[i]);
+                    }
+                }
+                event.targets.sort(lib.sort.seat);
+				player.line(event.targets,'thunder');
+                "step 1"
+                if(event.targets.length){
+                    event.targets.shift().damage('thunder');
+                    event.redo();
+                }
+            },
+			ai:{
+				threaten:function(player,target){
+					if(target.hp==1) return 2;
+					if(target.hp==2&&game.players.length<8) return 1.5;
+					return 0.5;
+				},
+			}
+        },
+		boss_fanshi:{
+            trigger:{player:'phaseEnd'},
+            forced:true,
+            check:function(){
+                return false;
+            },
+            content:function(){
+                player.loseHp();
+            }
+        },
+		boss_skonghun:{
+			trigger:{player:'phaseUseBegin'},
+			filter:function(event,player){
+				var num=player.maxHp-player.hp;
+				for(var i=0;i<game.players.length;i++){
+					if(game.players[i].side!=player.side){
+						num--;
+					}
+				}
+				return num>=0;
+			},
+			forced:true,
+			content:function(){
+				'step 0'
+				var targets=[];
+				for(var i=0;i<game.players.length;i++){
+					if(game.players[i].side!=player.side){
+						targets.push(game.players[i]);
+					}
+				}
+				targets.sort(lib.sort.seat);
+				event.targets=targets;
+				player.line(targets,'thunder');
+				event.num=targets.length;
+				'step 1'
+				if(event.targets.length){
+					event.targets.shift().damage('thunder');
+					event.redo();
+				}
+				'step 2'
+				player.recover(event.num);
+			}
+		},
+		boss_chiying:{
+            trigger:{global:'damageBegin'},
+            forced:true,
+            filter:function(event,player){
+                if(event.num<=1) return false;
+				if(typeof player.side=='boolean'){
+					return player.side==event.player.side;
+				}
+                return player==event.player;
+            },
+            priority:-11,
+            content:function(){
+                trigger.num=1;
+            }
+        },
+		boss_jingfan:{
+			global:'boss_jingfan2',
+		},
+		boss_jingfan2:{
+			mod:{
+				globalFrom:function(from,to,distance){
+					if(typeof from.side=='boolean'){
+						for(var i=0;i<game.players.length;i++){
+							if(game.players[i].skills.contains('boss_jingfan')&&
+								game.players[i].side==from.side&&game.players[i]!=from){
+								return distance-1;
+							}
+						}
+					}
+				}
+			}
+		},
 		boss_bianshen2:{
 			mode:['boss'],
 			global:'boss_bianshen2x'
@@ -747,7 +874,7 @@ character.boss={
 			}
 		},
 		boss_wange:{
-			inherit:'guiji'
+			inherit:'boss_guiji'
 		},
 		fengwu:{
 			audio:2,
@@ -1125,7 +1252,32 @@ character.boss={
 		},
 		boss_tianyu:{
 			audio:true,
-			inherit:'suoling'
+			trigger:{player:'phaseEnd'},
+            forced:true,
+            filter:function(event,player){
+                if(player.isLinked()) return true;
+                for(var i=0;i<game.players.length;i++){
+                    if(game.players[i]!=player&&!game.players[i].isLinked()){
+                        return true;
+                    }
+                }
+                return false;
+            },
+            content:function(){
+                "step 0"
+                event.targets=game.players.slice(0);
+                event.targets.remove(player);
+                event.targets.sort(lib.sort.seat);
+                if(player.isLinked()) player.link();
+                "step 1"
+                if(event.targets.length){
+                    var target=event.targets.shift();
+                    if(!target.isLinked()){
+                        target.link();
+                    }
+                    event.redo();
+                }
+            }
 		},
 		boss_jizhi:{
 			audio:2,
@@ -1311,6 +1463,7 @@ character.boss={
 			forced:true,
 			priority:100,
 			audio:2,
+			mode:['identity','guozhan','boss','stone'],
 			filter:function(event,player){
 				return player.hp<=4
 			},
@@ -1362,6 +1515,51 @@ character.boss={
 				player.draw(4,false);
 			}
 		},
+		qiwu:{
+            audio:true,
+            trigger:{player:'useCard'},
+            forced:true,
+            filter:function(event,player){
+                return get.suit(event.card)=='club'&&player.hp<player.maxHp;
+            },
+            content:function(){
+                player.recover();
+            }
+        },
+		jizhen:{
+            trigger:{player:'phaseEnd'},
+            direct:true,
+            filter:function(event,player){
+                for(var i=0;i<game.players.length;i++){
+                    if(game.players[i].hp<game.players[i].maxHp&&player!=game.players[i]){
+                        return true;
+                    }
+                }
+            },
+            content:function(){
+                "step 0"
+                var num=0;
+                for(var i=0;i<game.players.length;i++){
+                    if(!game.players[i].isLinked()&&player!=game.players[i]){
+                        num++;
+                    }
+                }
+                player.chooseTarget('是否发动【激阵】？',[1,2],function(card,player,target){
+                    return target.hp<target.maxHp&&player!=target;
+                }).ai=function(target){
+                    return ai.get.attitude(player,target);
+                }
+                "step 1"
+                if(result.bool){
+                    player.logSkill('jizhen',result.targets);
+                    game.asyncDraw(result.targets);
+                }
+            },
+            ai:{
+                expose:0.3,
+                threaten:1.3
+            }
+        },
 	},
 	translate:{
 		boss_chi:'魑',
@@ -1375,6 +1573,40 @@ character.boss={
 		boss_luocha:'罗刹',
 		boss_yecha:'夜叉',
 
+		boss_liedixuande:'烈帝玄德',
+		boss_gongshenyueying:'工神月英',
+		boss_tianhoukongming:'天侯孔明',
+		boss_yuhuoshiyuan:'浴火士元',
+		boss_qiaokuijunyi:'巧魁儁乂',
+		boss_jiarenzidan:'佳人子丹',
+		boss_duanyuzhongda:'断狱仲达',
+		boss_juechenmiaocai:'绝尘妙才',
+
+		boss_baihumech:'机雷白虎',
+		boss_qinglongmech:'云屏青龙',
+		boss_xuanwumech:'灵甲玄武',
+		boss_zhuquemech:'炽羽朱雀',
+		boss_bianmech:'缚地狴犴',
+		boss_chiwenmech:'吞天螭吻',
+		boss_suannimech:'食火狻猊',
+		boss_yazimech:'裂石睚眦',
+
+		boss_skonghun:'控魂',
+		boss_skonghun_info:'出牌阶段开始时，若你已损失体力值不小于敌方角色数，你可以对所有敌方角色各造成1点雷电伤害，然后你恢复X点体力（X为受到伤害的角色数）',
+		boss_fanshi:'反噬',
+		boss_fanshi_info:'锁定技，结束阶段，你失去1点体力',
+		boss_xuanlei:'玄雷',
+		boss_xuanlei_info:'锁定技，准备阶段，令所有判定区内有牌的敌方角色受到1点雷电伤害',
+		boss_chiying:'持盈',
+		boss_chiying_info:'锁定技，每当己方角色受到多于1伤害时，你防止其余伤害',
+		boss_jingfan:'惊帆',
+		boss_jingfan_info:'锁定技，己方其他角色计算与敌方角色距离时，始终-1',
+
+        qiwu:'栖梧',
+        qiwu_info:'锁定技。每当你使用一张梅花牌，你回复一点体力',
+        jizhen:'激阵',
+        jizhen_info:'结束阶段，你可以令所至多两名已受伤角色摸一张牌',
+
 		boss_yushou:'驭兽',
 		boss_yushou_info:'出牌阶段开始时，视为你使用了一张[南蛮入侵]',
 		boss_moyany:'魔炎',
@@ -1447,7 +1679,7 @@ character.boss={
 		boss_konghun:'控心',
 		boss_konghun_info:'回合结束阶段，你可以指定一名敌人令其进入混乱状态（不受对方控制，并将队友视为敌人）直到下一回合开始',
 		yuehun:'月魂',
-		yuehun_info:'回合开始阶段，你可以回复一点体力并摸两张牌',
+		yuehun_info:'回合结束阶段，你可以回复一点体力并摸两张牌',
 		fengwu:'风舞',
 		fengwu_info:'出牌阶段限一次，可令除你外的所有角色依次对与其距离最近的另一名角色使用一张【杀】，无法如此做者失去1点体力。',
 		boss_wange:'笙歌',
@@ -1477,6 +1709,7 @@ character.boss={
 		// boss_yuhuo:'浴火',
 		// boss_yuhuo_info:'觉醒技，在你涅槃后，你获得技能【神威】、【朱羽】',
 		boss_tianyu:'天狱',
+		boss_tianyu_info:'锁定技，回合结束阶段，你解除横置状态，除你之外的所有角色进入横置状态',
 
 		boss_juejing:'绝境',
 		boss_juejing2:'绝境',

character/fire.js

@@ -1,527 +0,0 @@
-'use strict';
-character.fire={
-	character:{
-		zhugeliangwolong:['male','shu',3,['huoji','bazhen','kanpo']],
-		pangtong:['male','shu',3,['lianhuan','niepan']],
-		xunyu:['male','wei',3,['quhu','jieming']],
-		dianwei:['male','wei',4,['qiangxi']],
-		taishici:['male','wu',4,['tianyi']],
-		yanwen:['male','qun',4,['shuangxiong']],
-		yuanshao:['male','qun',4,['luanji','xueyi'],['zhu']],
-		pangde:['male','qun',4,['mashu','mengjin']],
-	},
-	perfectPair:{
-		zhugeliangwolong:['pangtong','huangyueying'],
-		yuanshao:['yanwen']
-	},
-	skill:{
-		huoji:{
-			audio:2,
-			enable:'chooseToUse',
-			filterCard:function(card){
-				return get.color(card)=='red';
-			},
-			viewAs:{name:'huogong',nature:'fire'},
-			viewAsFilter:function(player){
-				if(!player.num('h',{color:'red'})) return false;
-			},
-			prompt:'将一张红色牌当火攻使用',
-			check:function(card){
-				var player=_status.currentPhase;
-				if(player.num('h')>player.hp){
-					return 6-ai.get.value(card);
-				}
-				return 4-ai.get.value(card)
-			}
-		},
-		bazhen:{
-			audio:2,
-			inherit:'bagua_skill',
-			filter:function(event,player){
-				if(!event.filterCard({name:'shan'})) return false;
-				if(event.parent.player.num('s','unequip')) return false;
-				if(player.get('e','2')) return false;
-				return true;
-			},
-			ai:{
-				effect:{
-					target:function(card,player,target){
-						if(player==target&&get.subtype(card)=='equip2'){
-							if(ai.get.equipValue(card)<=8) return 0;
-						}
-						if(target.num('e','2')) return;
-						if(player.skills.contains('unequip')) return;
-						if(get.tag(card,'respondShan')) return [0.5,0];
-					}
-				}
-			}
-		},
-		kanpo:{
-			audio:2,
-			enable:'chooseToUse',
-			filterCard:function(card){
-				return get.color(card)=='black';
-			},
-			viewAsFilter:function(player){
-				return player.num('h',{color:'black'})>0;
-			},
-			viewAs:{name:'wuxie'},
-			prompt:'将一张黑色牌当无懈可击使用',
-			check:function(card){return 8-ai.get.value(card)},
-			threaten:1.2
-		},
-		lianhuan:{
-			group:['lianhuan1','lianhuan2']
-		},
-		lianhuan1:{
-			audio:2,
-			enable:'phaseUse',
-			filter:function(event,player){
-				return player.num('h',{suit:'club'})>0;
-			},
-			filterCard:function(card){
-				return get.suit(card)=='club';
-			},
-			viewAs:{name:'tiesuo'},
-			prompt:'将一张梅花牌当铁锁连环使用',
-			check:function(card){return 4-ai.get.value(card)}
-		},
-		lianhuan2:{
-			audio:2,
-			enable:'phaseUse',
-			filter:function(event,player){
-				return player.num('h',{suit:'club'})>0;
-			},
-			filterCard:function(card){
-				return get.suit(card)=='club';
-			},
-			check:function(card){
-				return 5-ai.get.useful(card);
-			},
-			content:function(){
-				player.draw();
-			},
-			discard:false,
-			prepare:function(cards,player){
-				player.$throw(cards);
-			},
-			ai:{
-				basic:{
-					order:1
-				},
-				result:{
-					player:1,
-				},
-			}
-		},
-		niepan:{
-			audio:2,
-			unique:true,
-			enable:'chooseToUse',
-			mark:true,
-			skillAnimation:true,
-			animationStr:'涅盘',
-			animationColor:'fire',
-			init:function(player){
-				player.storage.niepan=false;
-			},
-			filter:function(event,player){
-				if(event.type!='dying') return false;
-				if(player!=_status.dying) return false;
-				if(player.storage.niepan) return false;
-			},
-			content:function(){
-				player.hp=Math.min(3,player.maxHp);
-				player.discard(player.get('hej'));
-				player.draw(3);
-				player.unmarkSkill('niepan');
-				if(player.classList.contains('linked')) player.link();
-				if(player.classList.contains('turnedover')) player.turnOver();
-				player.storage.niepan=true;
-			},
-			ai:{
-				skillTagFilter:function(player){
-					if(player.storage.niepan) return false;
-					if(player.hp>0) return false;
-				},
-				save:true,
-				result:{
-					player:10
-				},
-				threaten:function(player,target){
-					if(!target.storage.niepan) return 0.6;
-				}
-			},
-			intro:{
-				content:'limited'
-			}
-		},
-		quhu:{
-			audio:2,
-			enable:'phaseUse',
-			usable:1,
-			filter:function(event,player){
-				if(player.num('h')==0) return false;
-				for(var i=0;i<game.players.length;i++){
-					if(game.players[i].hp>player.hp&&game.players[i].num('h')) return true;
-				}
-				return false;
-			},
-			filterTarget:function(card,player,target){
-				return target.hp>player.hp&&target.num('h')>0;
-			},
-			content:function(){
-				"step 0"
-				player.chooseToCompare(target);
-				"step 1"
-				if(result.bool){
-					player.chooseTarget(function(card,player,target1){
-						return target1!=target&&get.distance(target,target1,'attack')<=1;
-					},true).ai=function(target1){
-						return ai.get.damageEffect(target1,target,player);
-					}
-				}
-				else{
-					player.damage(target);
-					event.finish();
-				}
-				"step 2"
-				if(result.bool&&result.targets&&result.targets.length){
-					result.targets[0].damage(target);
-				}
-			},
-			ai:{
-				order:0.5,
-				result:{
-					target:function(player,target){
-						var att=ai.get.attitude(player,target);
-						var oc=(target.num('h')==1);
-						if(att>0&&oc) return 0;
-						for(var i=0;i<game.players.length;i++){
-							if(game.players[i]!=target&&game.players[i]!=player&&
-								get.distance(target,game.players[i],'attack')<=1){
-								if(ai.get.damageEffect(game.players[i],target,player)>0){
-									return att>0?att/2:att-(oc?5:0);
-								}
-							}
-						}
-						return 0;
-					},
-					player:function(player,target){
-						if(target.skills.contains('jueqing')) return -10;
-						var mn=1;
-						var hs=player.get('h');
-						for(var i=0;i<hs.length;i++){
-							mn=Math.max(mn,hs[i].number);
-						}
-						if(mn<=11&&player.hp<2) return -20;
-						var max=player.maxHp-hs.length;
-						for(var i=0;i<game.players.length;i++){
-							if(ai.get.attitude(player,game.players[i])>2){
-								max=Math.max(Math.min(5,game.players[i].hp)-game.players[i].num('h'),max);
-							}
-						}
-						switch(max){
-							case 0:return mn==13?0:-20;
-							case 1:return mn>=12?0:-15;
-							case 2:return 0;
-							case 3:return 1;
-							default:return max;
-						}
-					}
-				},
-				expose:0.2
-			}
-		},
-		jieming:{
-			audio:2,
-			trigger:{player:'damageEnd'},
-			direct:true,
-			filter:function(event,player){
-				return event.num>0
-			},
-			content:function(){
-				"step 0"
-				player.chooseTarget([1,trigger.num],function(card,player,target){
-					return target.num('h')<Math.min(target.maxHp,5);
-				}).ai=function(target){
-					var att=ai.get.attitude(_status.event.player,target);
-					if(att>2){
-						return Math.min(5,target.maxHp)-target.num('h');
-					}
-					return att/3;
-				}
-				"step 1"
-				if(result.bool){
-					player.logSkill('jieming',result.targets);
-					for(var i=0;i<result.targets.length;i++){
-						result.targets[i].draw(Math.min(5,result.targets[i].maxHp)-result.targets[i].num('h'));
-					}
-				}
-			},
-			ai:{
-				maixie:true,
-				effect:{
-					target:function(card,player,target,current){
-						if(get.tag(card,'damage')&&target.hp>1){
-							if(player.skills.contains('jueqing')) return [1,-2];
-							var max=0;
-							for(var i=0;i<game.players.length;i++){
-								if(ai.get.attitude(target,game.players[i])>0){
-									max=Math.max(Math.min(5,game.players[i].hp)-game.players[i].num('h'),max);
-								}
-							}
-							switch(max){
-								case 0:return 2;
-								case 1:return 1.5;
-								case 2:return [1,2];
-								default:return [0,max];
-							}
-						}
-						if((card.name=='tao'||card.name=='caoyao')&&
-							target.hp>1&&target.num('h')<=target.hp) return [0,0];
-					}
-				},
-			}
-		},
-		qiangxi:{
-			audio:2,
-			enable:'phaseUse',
-			usable:1,
-			filterCard:function(card){
-				return get.subtype(card)=='equip1';
-			},
-			selectCard:[0,1],
-			filterTarget:function(card,player,target){
-				if(player==target) return false;
-				return get.distance(player,target,'attack')<=1;
-			},
-			content:function(){
-				"step 0"
-				if(cards.length==0){
-					player.loseHp();
-				}
-				"step 1"
-				target.damage();
-			},
-			check:function(card){
-				return 10-ai.get.value(card);
-			},
-			position:'he',
-			ai:{
-				order:8,
-				result:{
-					player:function(player,target){
-						if(ui.selected.cards.length) return 0;
-						if(player.hp>=target.hp) return -0.9;
-						if(player.hp<=2) return -10;
-						return -2;
-					},
-					target:function(player,target){
-						if(player.hp<=2) return 0;
-						return ai.get.damageEffect(target,player);
-					}
-				}
-			},
-			threaten:1.3
-		},
-		tianyi:{
-			audio:2,
-			enable:'phaseUse',
-			usable:1,
-			filterTarget:function(card,player,target){
-				return player!=target&&target.num('h')>0;
-			},
-			filter:function(event,player){
-				return player.num('h')>0;
-			},
-			content:function(){
-				"step 0"
-				player.chooseToCompare(target);
-				"step 1"
-				if(result.bool){
-					player.addTempSkill('tianyi2','phaseAfter');
-				}
-				else{
-					player.addTempSkill('tianyi3','phaseAfter');
-				}
-			},
-			ai:{
-				order:function(name,player){
-					var cards=player.get('h');
-					if(player.num('h','sha')==0){
-						return 1;
-					}
-					for(var i=0;i<cards.length;i++){
-						if(cards[i].name!='sha'&&cards[i].number>11&&ai.get.value(cards[i])<7){
-							return 9;
-						}
-					}
-					return lib.card.sha.ai.order-1;
-				},
-				result:{
-					player:function(player){
-						if(player.num('h','sha')>0) return 0.6;
-						var num=player.num('h');
-						if(num>player.hp) return 0;
-						if(num==1) return -2;
-						if(num==2) return -1;
-						return -0.7;
-					},
-					target:function(player,target){
-						var num=target.num('h');
-						if(num==1) return -1;
-						if(num==2) return -0.7;
-						return -0.5
-					},
-				},
-				threaten:1.3
-			}
-		},
-		tianyi2:{
-			mod:{
-				targetInRange:function(card,player,target,now){
-					if(card.name=='sha') return true;
-				},
-				selectTarget:function(card,player,range){
-					if(card.name=='sha'&&range[1]!=-1) range[1]++;
-				},
-				cardUsable:function(card,player,num){
-					if(card.name=='sha') return num+1;
-				}
-			},
-		},
-		tianyi3:{
-			mod:{
-				cardEnabled:function(card){if(card.name=='sha') return false}
-			}
-		},
-		shuangxiong:{
-			audio:true,
-			trigger:{player:'phaseDrawBefore'},
-			check:function(event,player){
-				if(player.num('h')>player.hp) return true;
-				if(player.num('h')>3) return true;
-				return false;
-			},
-			content:function(){
-				"step 0"
-				player.judge(ui.special);
-				"step 1"
-				player.gain(result.card);
-				player.$gain2(result.card);
-				player.addTempSkill('shuangxiong2','phaseAfter');
-				player.storage.shuangxiong=get.color(result.card);
-				trigger.untrigger();
-				trigger.finish();
-			}
-		},
-		shuangxiong2:{
-			audio:true,
-			enable:'phaseUse',
-			viewAs:{name:'juedou'},
-			filterCard:function(card,player){
-				return get.color(card)!=player.storage.shuangxiong;
-			},
-			check:function(card){
-				return 6-ai.get.value(card);
-			},
-			ai:{
-				basic:{
-					order:10
-				}
-			}
-		},
-		luanji:{
-			audio:2,
-			enable:'phaseUse',
-			viewAs:{name:'wanjian'},
-			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;
-			},
-			selectCard:2,
-			check:function(card){
-				return 6-ai.get.value(card);
-			},
-			ai:{
-				basic:{
-					order:10
-				}
-			}
-		},
-		xueyi:{
-			mod:{
-				maxHandcard:function(player,num){
-					if(player.isZhu){
-						for(var i=0;i<game.players.length;i++){
-							if(player!=game.players[i]&&game.players[i].group=='qun') num+=2;
-						}
-					}
-					return num;
-				}
-			}
-		},
-		mengjin:{
-			audio:2,
-			trigger:{player:'shaMiss'},
-			priority:-1,
-			filter:function(event){
-				return event.target.num('he')>0;
-			},
-			check:function(event,player){
-				return ai.get.attitude(player,event.target)<0;
-			},
-			content:function(){
-				player.discardPlayerCard('he',trigger.target,true);
-			}
-		},
-	},
-	translate:{
-		zhugeliangwolong:'卧龙',
-		pangtong:'庞统',
-		xunyu:'荀彧',
-		dianwei:'典韦',
-		taishici:'太史慈',
-		yanwen:'颜良文丑',
-		yuanshao:'袁绍',
-		pangde:'庞德',
-		huoji:'火计',
-		bazhen:'八阵',
-		kanpo:'看破',
-		lianhuan:'连环',
-		lianhuan1:'连环',
-		lianhuan2:'重铸♣︎',
-		niepan:'涅槃',
-		quhu:'驱虎',
-		jieming:'节命',
-		qiangxi:'强袭',
-		tianyi:'天义',
-		shuangxiong:'双雄',
-		shuangxiong2:'双雄',
-		luanji:'乱击',
-		xueyi:'血裔',
-		mengjin:'猛进',
-		huoji_info:'出牌阶段，你可以将你的任意一张♥或♦手牌当【火攻】使用。',
-		bazhen_info:'当你没装备防具时，始终视为你装备着【八卦阵】。',
-		kanpo_info:'你可以将你的任意一张♠或♣手牌当【无懈可击】使用。',
-		lianhuan_info:'出牌阶段，你可以将你任意一张梅花手牌当【铁索连环】使用或重铸。',
-		niepan_info:'限定技，当你处于濒死状态时，你可以丢弃你所有的牌和你判定区里的牌，并重置你的武将牌，然后摸三张牌且体力回复至3点。',
-		quhu_info:'出牌阶段，你可以与一名体力比你多的角色拼电，若你赢，则该角色对其攻击范围内另一名由你指定的角色造成1点伤害。若你没赢，他/她对你造成一点伤害。每回合限用一次。',
-		jieming_info:'你每受到1点伤害，可令任意一名角色将手牌补至其体力上限的张数(不能超过五张)。',
-		qiangxi_info:'出牌阶段，你可以自减一点体力或弃一张武器牌，然后你对你攻击范围内的一名角色造成一点伤害，每回合限一次。',
-		tianyi_info:'出牌阶段，你可以和一名角色拼点，若你赢，你获得以下技能直到回合结束：攻击范围无限；可额外使用一张【杀】；使用【杀】时可额外指定一个目标，若你没赢，你不能使用【杀】直到回合结束。每回合限一次。',
-		shuangxiong_info:'摸牌阶段，你可选择放弃摸牌并进行一次判定：你获得此判定牌，且于此回合的出牌阶段，你可以将任意一张与此判定牌不同颜色的手牌当【决斗】使用。',
-		luanji_info:'出牌阶段，你可以将任意两张相同花色的手牌当【万箭齐发】使用。',
-		xueyi_info:'场上每有一名其他群雄角色存活，你的手牌上限便+2。',
-		mengjin_info:'当你使用的【杀】被【闪】抵消时，你可以弃掉对方的一张牌。',
-	},
-}

character/gujian.js

@@ -775,7 +775,8 @@ character.gujian={
 				}
 			},
 			ai:{
-				expose:0.2
+				expose:0.2,
+				threaten:1.3
 			}
 		},
 		yangming:{
@@ -804,7 +805,8 @@ character.gujian={
 						return 1;
 					}
 				},
-				order:6
+				order:6,
+				threaten:1.3
 			}
 		},
 		yangming2:{

character/guozhan.js

@@ -12,5 +12,6 @@ character.guozhan={
 		hetaihou:['female','qun',3,['zhendu','qiluan']],
 		kongrong:['male','qun',3,['lirang','mingshi']],
 		dingfeng:['male','wu',4,['fenxun']],
+		panfeng:['male','qun',4,['kuangfu']],
 	},
 };

character/jiange.js

@@ -249,7 +249,7 @@ character.jiange={
         lingfeng:{
             trigger:{player:'phaseDrawBefore'},
             check:function(event,player){
-                for(i=0;i<game.players.length;i++){
+                for(var i=0;i<game.players.length;i++){
                     if(player!=game.players[i]){
                         if(ai.get.attitude(player,game.players[i])<0) return true;
                     }
@@ -455,17 +455,6 @@ character.jiange={
                 threaten:1.3
             }
         },
-        qiwu:{
-            audio:true,
-            trigger:{player:'useCard'},
-            forced:true,
-            filter:function(event,player){
-                return get.suit(event.card)=='club'&&player.hp<player.maxHp;
-            },
-            content:function(){
-                player.recover();
-            }
-        },
         tianyu:{
             trigger:{player:'phaseEnd'},
             direct:true,
@@ -553,7 +542,6 @@ character.jiange={
         jg_caozhen:'佳人子丹',
         jg_zhanghe:'巧魁儁乂',
         jg_simayi:'断狱仲达',
-        qiwu:'栖梧',
         tianyu:'天狱',
         zhinang:'智囊',
         jingmiao:'精妙',
@@ -579,7 +567,6 @@ character.jiange={
         biantian_info:'锁定技，准备阶段，你进行一次判定，若为红色，你可以选择至多三名角色进入“狂风”状态直到你的下一回合开始，若为黑桃，直到下个回合开始前，你处于“大雾”状态',
         jingmiao_info:'每当有一名其他角色使用无懈可击，你可以弃置其一张牌',
         zhinang_info:'准备阶段，你可以亮出牌堆顶的三张牌，你可以将其中锦囊或装备牌交给一名角色，然后将其余牌置入弃牌堆',
-        qiwu_info:'锁定技。每当你使用一张梅花牌，你回复一点体力',
         tianyu_info:'回合结束阶段，你可以将任意名未横置的其他角色横置',
         juechen:'绝尘',
         juechen_info:'每当你使用一张杀，可以弃置一名其他角色的一张牌（不能是杀的目标）',

character/rank.js

@@ -254,6 +254,7 @@ window.characterRank={
         'quancong',
         'yxs_luocheng',
         'yxs_napolun',
+        'caoren',
     ],
     b:[
         'yxs_lishimin',
@@ -336,7 +337,7 @@ window.characterRank={
         'yxs_mingchenghuanghou',
         'pangtong',
         'yxs_libai',
-        'zhugeliangwolong',
+        'sp_zhugeliang',
         'shen_guanyu',
         'jiangfei',
         're_caocao',
@@ -371,7 +372,6 @@ window.characterRank={
         'huaxiong',
         'xiahouyuan',
         'liaohua',
-        'caoren',
         'huangzhong',
         'zhaoyun',
         'machao',
@@ -388,6 +388,7 @@ window.characterRank={
     ],
     d:[
         'menghuo',
+        'panfeng',
         'sunru',
         'zhoucang',
         'weiyan',

character/refresh.js

@@ -1011,7 +1011,7 @@ character.refresh={
 				!lib.filter.autoRespondSha.call({player:player});
 			},
 			content:function(){
-				player.chooseToUse({name:'sha'},'是否对'+get.translation(trigger.player)+'使用一张杀',
+				player.chooseToUse({name:'sha'},'诛害：是否对'+get.translation(trigger.player)+'使用一张杀',
 					trigger.player).logSkill='zhuhai';
 			}
 		},

character/sp.js

@@ -40,6 +40,10 @@ character.sp={
 		sunru:['female','wu',3,['shixin','qingyi']],
 		lingju:['female','qun',3,['jieyuan','fenxin']],
 		lifeng:['male','shu',3,['tunchu','shuliang']],
+
+		// zhuling:['male','wei',4,['zhanyi']],
+		sunluyu:['female','wu',3,['meibu','mumu']],
+		hanba:['female','qun',4,['fentian','zhiri']],
 	},
 	perfectPair:{
 		zhugejin:['zhugeke'],
@@ -58,6 +62,262 @@ character.sp={
 		caohong:['caoren'],
 	},
 	skill:{
+		meibu:{
+			trigger:{global:'phaseUseBegin'},
+			filter:function(event,player){
+				return event.player!=player&&get.distance(event.player,player,'attack')>1;
+			},
+			prompt:function(event,player){
+				return '是否对'+get.translation(event.player)+'发动【魅步】？'
+			},
+			check:function(event,player){
+				if(ai.get.attitude(player,event.player)>=0) return false;
+				var e2=player.get('e','2');
+				if(e2){
+					if(e2.name=='tengjia') return true;
+					if(e2.name=='bagua') return	true;
+				}
+				return player.num('h','shan')>0;
+			},
+			content:function(){
+				var target=trigger.player;
+				player.line(target,'green');
+				target.addTempSkill('meibu_viewas','phaseAfter');
+				target.addTempSkill('meibu_range','phaseAfter');
+				target.storage.meibu=player;
+				target.marks.meibu=target.markCharacter(player,{
+					name:'魅步',
+					content:'锦囊牌均视为杀且'+get.translation(player)+'视为在攻击范围内'
+				});
+				game.addVideo('markCharacter',target,{
+					name:'魅步',
+					content:'锦囊牌均视为杀且'+get.translation(player)+'视为在攻击范围内',
+					id:'meibu',
+					target:player.dataset.position
+				});
+			},
+			ai:{
+				expose:0.2
+			},
+			subSkill:{
+				range:{
+					mod:{
+						targetInRange:function(card,player,target){
+							if(card.name=='sha'&&target==player.storage.meibu){
+								return true;
+							}
+						}
+					},
+					onremove:function(player){
+						if(player.marks.meibu){
+							player.marks.meibu.delete();
+							delete player.marks.meibu;
+							game.addVideo('unmark',player,'meibu');
+						}
+					},
+					trigger:{player:'useCard'},
+					forced:true,
+					popup:false,
+					filter:function(event,player){
+						return event.skill=='meibu_viewas'
+					},
+					content:function(){
+						player.removeSkill('meibu_viewas');
+						if(player.marks.meibu&&player.marks.meibu.info){
+							player.marks.meibu.info.content=player.marks.meibu.info.content.slice(8);
+						}
+					}
+				},
+				viewas:{
+					mod:{
+						cardEnabled:function(card,player){
+							if(card.name!='sha'&&get.type(card,'trick')=='trick') return false;
+						},
+						cardUsable:function(card,player){
+							if(card.name!='sha'&&get.type(card,'trick')=='trick') return false;
+						},
+						cardRespondable:function(card,player){
+							if(card.name!='sha'&&get.type(card,'trick')=='trick') return false;
+						},
+						cardSavable:function(card,player){
+							if(card.name!='sha'&&get.type(card,'trick')=='trick') return false;
+						},
+					},
+					enable:['chooseToUse','chooseToRespond'],
+					filterCard:function(card){
+						return get.type(card,'trick')=='trick';
+					},
+					viewAs:{name:'sha'},
+					check:function(){return 1},
+					ai:{
+						effect:{
+							target:function(card,player,target,current){
+								if(get.tag(card,'respondSha')&&current<0) return 0.8
+							}
+						},
+						respondSha:true,
+						order:4,
+						useful:-1,
+						value:-1
+					}
+				}
+			}
+		},
+		mumu:{
+			enable:'phaseUse',
+			// usable:1,
+			filterCard:function(card,player,target){
+				return card.name=='sha'||(get.type(card,'trick')=='trick'&&get.color(card)=='black');
+			},
+			check:function(card){
+				return 7-ai.get.value(card);
+			},
+			filterTarget:function(card,player,target){
+				if(target==player) return false;
+				return target.get('e','1')||target.get('e','2');
+			},
+			content:function(){
+				'step 0'
+				var e1=target.get('e','1');
+				var e2=target.get('e','2');
+				event.e1=e1;
+				event.e2=e2;
+				if(e1&&e2){
+					player.chooseControl('武器牌','防具牌').ai=function(){
+						if(player.get('e','2')){
+							return '武器牌';
+						}
+						return '防具牌';
+					}
+				}
+				else if(e1){
+					event.choice='武器牌';
+				}
+				else{
+					event.choice='防具牌';
+				}
+				'step 1'
+				var choice=event.choice||result.control;
+				if(choice=='武器牌'){
+					target.discard(event.e1);
+					player.draw();
+				}
+				else{
+					player.equip(event.e2);
+					target.$give(event.e2,player);
+				}
+			},
+			ai:{
+				order:8,
+				result:{
+					target:function(player,target){
+						if(target.get('e','2')&&!player.get('e','2')){
+							return -2;
+						}
+						return -1;
+					}
+				}
+			}
+		},
+		fentian:{
+			audio:2,
+			trigger:{player:'phaseEnd'},
+			direct:true,
+			filter:function(event,player){
+				if(player.num('h')>=player.hp) return false;
+				for(var i=0;i<game.players.length;i++){
+					if(player!=game.players[i]&&get.distance(player,game.players[i],'attack')<=1){
+						return true;
+					}
+				}
+				return false;
+			},
+			intro:{
+				content:'cards',
+			},
+			init:function(player){
+				player.storage.fentian=[];
+			},
+			content:function(){
+				'step 0'
+				player.chooseTarget('焚天：选择一名攻击范围内的角色，将其一张牌置于你的武将牌上',true,function(card,player,target){
+					return player!=target&&get.distance(player,target,'attack')<=1;
+				}).ai=function(target){
+					return -ai.get.attitude(player,target)
+				}
+				'step 1'
+				if(result.bool){
+					player.logSkill('fentian',result.targets);
+					event.target=result.targets[0];
+					player.choosePlayerCard(result.targets[0],'he',true);
+				}
+				else{
+					event.finish();
+				}
+				'step 2'
+				if(result.bool){
+					event.target.$give(result.links,player);
+					event.target.lose(result.links,ui.special);
+					player.storage.fentian=player.storage.fentian.concat(result.links);
+					player.syncStorage('fentian');
+					setTimeout(function(){
+						player.markSkill('fentian');
+					},700);
+				}
+			},
+			mod:{
+				attackFrom:function(from,to,distance){
+					return distance-from.storage.fentian.length;
+				}
+			}
+		},
+		zhiri:{
+			trigger:{player:'phaseBegin'},
+			forced:true,
+			unique:true,
+			audio:2,
+			skillAnimation:true,
+			animationColor:'fire',
+			filter:function(event,player){
+				return player.storage.fentian&&player.storage.fentian.length>=3&&!player.storage.zhiri;
+			},
+			content:function(){
+				player.loseMaxHp();
+				player.addSkill('xintan');
+				player.storage.zhiri=true;
+			}
+		},
+		xintan:{
+			enable:'phaseUse',
+			usable:1,
+			audio:2,
+			unique:true,
+			filter:function(event,player){
+				return player.storage.fentian&&player.storage.fentian.length>=2;
+			},
+			filterTarget:true,
+			prompt:'两张“焚”置入弃牌堆并令一名角色失去一点体力',
+			content:function(){
+				'step 0'
+				player.chooseCardButton(2,'两张“焚”置入弃牌堆并令'+get.translation(target)+'失去一点体力',player.storage.fentian,true);
+				'step 1'
+				if(result.bool){
+					player.$throw(result.links);
+					for(var i=0;i<result.links.length;i++){
+						player.storage.fentian.remove(result.links[i]);
+						ui.discardPile.appendChild(result.links[i]);
+					}
+					player.syncStorage('fentian');
+					target.loseHp();
+				}
+			},
+			ai:{
+				order:8,
+				result:{
+					target:-1
+				}
+			}
+		},
 		danji:{
 			skillAnimation:true,
 			trigger:{player:'phaseBegin'},
@@ -1089,7 +1349,8 @@ character.sp={
 			},
 			content:function(){
 				"step 0"
-				if(player.storage.kunfen){
+				if(player.storage.kunfen||
+				(lib.config.mode=='guozhan'&&player.hiddenSkills.contains('kunfen'))){
 					player.chooseBool('是否发动【困奋】？').ai=function(){
 						if(player.hp>3) return true;
 						if(player.hp==3&&player.num('h')<3) return true;
@@ -2405,26 +2666,60 @@ character.sp={
 		suishi:{
 			trigger:{global:'dying'},
 			forced:true,
+			popup:false,
 			priority:6,
 			filter:function(event,player){
-				return event.player!=player;
+				return event.player!=player&&event.parent.name=='damage'&&event.parent.source&&event.parent.source!=event.player;
 			},
 			content:function(){
-				player.draw();
+				'step 0'
+				var str;
+				if(trigger.parent.source==player){
+					str='随势：是否摸一张牌？';
+				}
+				else{
+					str='随势：是否令'+get.translation(player)+'摸一张牌？'
+				}
+				trigger.parent.source.chooseBool(str).ai=function(){
+					return ai.get.attitude(trigger.parent.source,player)>0;
+				};
+				'step 1'
+				if(result.bool){
+					player.logSkill('suishi');
+					trigger.parent.source.line(player,'green');
+					player.draw();
+				}
 			},
 			group:'suishi2'
 		},
 		suishi2:{
 			trigger:{global:'dieAfter'},
 			forced:true,
+			popup:false,
 			check:function(){
 				return false;
 			},
 			filter:function(event,player){
-				return event.player!=player;
+				return event.player!=player&&event.source&&event.source!=player&&event.source!=event.player;
 			},
 			content:function(){
-				player.loseHp();
+				'step 0'
+				var str;
+				if(trigger.source==player){
+					str='随势：是否流失一点体力？';
+				}
+				else{
+					str='随势：是否令'+get.translation(player)+'流失一点体力？'
+				}
+				trigger.source.chooseBool(str).ai=function(){
+					return ai.get.attitude(trigger.source,player)<0;
+				};
+				'step 1'
+				if(result.bool){
+					player.logSkill('suishi');
+					trigger.source.line(player,'green');
+					player.loseHp();
+				}
 			},
 		},
 		sijian:{
@@ -3727,7 +4022,32 @@ character.sp={
 					result.targets[0].draw(3);
 				}
 			}
-		}
+		},
+		kuangfu:{
+			trigger:{source:'damageEnd'},
+			direct:true,
+			audio:2,
+			filter:function(event){
+				return event.card&&event.card.name=='sha'&&event.player.num('e');
+			},
+			content:function(){
+				"step 0"
+				var neg=ai.get.attitude(player,trigger.player)<=0;
+				player.choosePlayerCard('e',trigger.player).ai=function(button){
+					if(neg){
+						return ai.get.buttonValue(button);
+					}
+					return 0;
+				};
+				"step 1"
+				if(result.bool){
+					player.logSkill('kuangfu');
+					trigger.player.$give(result.links,player);
+					game.delay(2);
+					player.equip(result.links[0]);
+				}
+			}
+		},
 	},
 	translate:{
 		chenlin:'陈琳',
@@ -3785,7 +4105,25 @@ character.sp={
 		lingju:'灵雎',
 		lifeng:'李丰',
 		jsp_guanyu:'sp关羽',
+		zhuling:'朱灵',
+		sunluyu:'孙鲁育',
+		hanba:'旱魃',
+		panfeng:'潘凤',
 
+		kuangfu:'狂斧',
+		kuangfu_info:'每当你使用杀造成伤害，可以将对方的一张装备牌移到你的装备区',
+		xintan:'心惔',
+		xintan_info:'出牌阶段限一次，你可以将两张“焚”置入弃牌堆并选择一名角色，该角色失去一点体',
+		fentian:'焚天',
+		fentian_info:'锁定技，结束阶段开始时，若你的手牌数少于体力值，你须选择一名攻击范围内的角色，将其一张牌置于你的武将牌上，称为“焚”。锁定技，你的攻击范围+X（X为“焚”的数量）',
+		zhiri:'炙日',
+		zhiri_info:'觉醒技，准备阶段开始时，若“焚”数不小于3，你减1点体力上限，然后获得技能“心惔”（出牌阶段限一次，你可以将两张“焚”置入弃牌堆并选择一名角色，该角色失去一点体力）',
+		meibu:'魅步',
+		meibu_info:'一名其他角色的出牌阶段开始时，若你不在其攻击范围内，你可以令该角色的锦囊牌均视为【杀】，直到该角色以此法使用了一张【杀】或回合结束。若如此做，则直到回合结束，视为你在其攻击范围内。',
+		mumu:'穆穆',
+		mumu_info:'出牌阶段限一次，你可以弃置一张【杀】或黑色锦囊牌，然后选择一项：弃置场上一张武器牌，然后摸一张牌；或将场上的一张防具牌移动到你的装备区里（可替换原防具）',
+		zhanyi:'战意',
+		zhanyi_info:'出牌阶段限一次，你可以弃置一张牌并失去1点体力，然后根据你弃置的牌获得以下效果直到回合结束：基本牌，你可以将一张基本牌当任意一张基本牌使用或打出；锦囊牌，摸两张牌且你使用的牌无距离限制；装备牌，你使用【杀】指定目标角色后，其弃置两张牌。',
 		nuzhan:'怒斩',
 		nuzhan_info:'锁定技，你使用的由一张锦囊牌转化而来的【杀】不计入限制的使用次数；锁定技，你使用的由一张装备牌转化而来的【杀】的伤害值基数+1',
 		danji:'单骑',
@@ -3976,7 +4314,7 @@ character.sp={
 		duanxie_info:'出牌阶段限一次，你可以令一名其他角色横置武将牌，若如此做，你横置武将牌。',
 		xiaoguo_info:'其他角色的结束阶段开始时，你可以弃置一张基本牌，令该角色选择一项：1.弃置一张装备牌并令你摸一张牌；2.受到你对其造成的1点伤害。',
 		sijian_info:'当你失去最后的手牌时，你可以弃置一名其他角色的一张牌。',
-		suishi_info:'锁定技。当一名其他角色进入濒死状态时，你摸一张牌；当一名其他角色死亡时，你失去1点体力。',
+		suishi_info:'每当其他角色进入濒死状态时，伤害来源可以令你摸一张牌；每当其他角色死亡时，伤害来源可以令你失去1点体力',
 		quji_info:'出牌阶段限一次，你可以弃置X张牌（X为你已损失的体力值），然后令至多X名已受伤的角色各回复1点体力。若你以此法弃置的牌中有黑色牌，你失去一点体力。',
 		junbing_info:'一名角色的结束阶段开始时，若其手牌数少于或者等于1，该角色可以摸一张牌。若如此做，该角色须将所有手牌交给你，然后你交给其等量的牌。',
 		shefu_info:'结束阶段开始时，你可以将一张手牌移出游戏，称为“伏兵”。然后为“伏兵”记录一个基本牌或锦囊牌名称(须与其他“伏兵”记录的名称均不同)。你的回合外，当有其他角色使用与你记录的“伏兵”牌名相同的牌时，你可以令此牌无效，然后将该“伏兵”置入弃牌堆。',

character/standard.js

@@ -408,7 +408,7 @@ character.standard={
 			viewAsFilter:function(player){
 				if(!player.num('h',{color:'black'})) return false;
 			},
-			prompt:'将一张黑色牌当闪打出',
+			prompt:'将一张黑色手牌当闪打出',
 			check:function(){return 1},
 			ai:{
 				respondShan:true,

character/swd.js

@@ -113,7 +113,7 @@ character.swd={
 		swd_sikongyu:['swd_muyue'],
 		swd_fengyu:['swd_ziqiao'],
 		swd_zhaoyun:['swd_hengai','swd_yeyaxi','zhaoyun'],
-		swd_hengai:['zhugeliang','zhugeliangwolong'],
+		swd_hengai:['zhugeliang','sp_zhugeliang'],
 		swd_duanmeng:['swd_shangzhang'],
 		swd_shangzhang:['swd_situqiang'],
 		swd_tuwei:['swd_hengai'],
@@ -559,30 +559,6 @@ character.swd={
 				}
 			},
 		},
-		kuangfu:{
-			trigger:{source:'damageEnd'},
-			direct:true,
-			filter:function(event){
-				return event.card&&event.card.name=='sha'&&event.player.num('e');
-			},
-			content:function(){
-				"step 0"
-				var neg=ai.get.attitude(player,trigger.player)<=0;
-				player.choosePlayerCard('e',trigger.player).ai=function(button){
-					if(neg){
-						return ai.get.buttonValue(button);
-					}
-					return 0;
-				};
-				"step 1"
-				if(result.bool){
-					player.logSkill('kuangfu');
-					trigger.player.$give(result.links,player);
-					game.delay(2);
-					player.equip(result.links[0]);
-				}
-			}
-		},
 		huajin:{
 			enable:'phaseUse',
 			usable:1,
@@ -4456,7 +4432,7 @@ character.swd={
 			trigger:{player:'phaseAfter'},
 			frequent:true,
 			filter:function(event,player){
-				return get.cardCount(true,player)>=3&&event.parent.name!='lingwu';
+				return get.cardCount(true,player)>=player.hp&&event.parent.name!='lingwu';
 			},
 			content:function(){
 				player.phase();
@@ -7768,8 +7744,6 @@ character.swd={
 		yaotong_info:'当你的手牌数为奇数时，你可以将一张手牌当作杀或闪使用或打出，当你的手牌数为偶数时，你可以将一张手牌当作无懈可击使用',
 		pojian:'破茧',
 		pojian_info:'每当你失去最后一张手牌，可以从牌堆中获得一张装备牌并装备之',
-		kuangfu:'狂斧',
-		kuangfu_info:'每当你使用杀造成伤害，可以将对方的一张装备牌移到你的装备区',
 		huajin:'化金',
 		huajin2:'化金',
 		huajin_info:'出牌阶段限一次，你可以弃置一张牌令你造成的伤害+1，直到你的下一回合开始',
@@ -7878,7 +7852,7 @@ character.swd={
 		benlei2:'奔雷',
 		benlei_info:'你可以将三张牌当惊雷闪使用；每当你造成一次雷属性伤害，你回复一点体力',
 		lingwu:'灵舞',
-		lingwu_info:'回合结束后，若你在本回合内使用了至少3张牌，你可以进行一个额外的回合（不可重复发动）',
+		lingwu_info:'回合结束后，若你在本回合内使用的牌数不少于当前体力值，你可以进行一个额外的回合（不可重复发动）',
 		miejing:'灭境',
 		miejing_info:'限制技，你可以弃置所有黑色牌，然后令所有其他角色受到一点雷电伤害',
 		lingxin:'灵心',

character/wind.js

@@ -1,561 +0,0 @@
-'use strict';
-character.wind={
-	character:{
-		xiahouyuan:['male','wei',4,['shensu']],
-		caoren:['male','wei',4,['jushou']],
-		huangzhong:['male','shu',4,['liegong']],
-		weiyan:['male','shu',4,['kuanggu']],
-		xiaoqiao:['female','wu',3,['tianxiang','hongyan']],
-		zhoutai:['male','wu',4,['buqu','fenji']],
-		zhangjiao:['male','qun',3,['leiji','guidao','huangtian'],['zhu']],
-		sp_zhangjiao:['male','qun',3,['diyleiji','guidao','huangtian'],['zhu']],
-		// spzhangjiao:['male','qun',3,['spleiji','guidao','huangtian'],['zhu']],
-		// yuji:['male','qun',3,['guhuo']],
-	},
-	skill:{
-		diyleiji:{
-			audio:2,
-			trigger:{player:'respond'},
-			filter:function(event,player){
-				return event.card.name=='shan';
-			},
-			direct:true,
-			content:function(){
-				"step 0";
-				player.chooseTarget('是否发动新雷击？').ai=function(target){
-					return ai.get.damageEffect(target,player,player,'thunder');
-				};
-				"step 1"
-				if(result.bool){
-					player.logSkill('diyleiji',result.targets,'thunder');
-					event.target=result.targets[0];
-					event.target.judge(function(card){
-						var suit=get.suit(card);
-						if(suit=='spade') return -4;
-						if(suit=='club') return -2;
-						return 0;
-					});
-				}
-				else{
-					event.finish();
-				}
-				"step 2"
-				if(result.suit=='club'){
-					event.target.damage('thunder');
-					player.recover();
-				}
-				else if(result.suit=='spade'){
-					event.target.damage(2,'thunder');
-				}
-			},
-			ai:{
-				effect:{
-					target:function(card,player,target,current){
-						if(get.tag(card,'respondShan')){
-							var hastarget=false;
-							for(var i=0;i<game.players.length;i++){
-								if(ai.get.attitude(target,game.players[i])<0){
-									hastarget=true;break;
-								}
-							}
-							var be=target.num('e',{color:'black'});
-							if(target.num('h','shan')&&be){
-								if(!target.skills.contains('guidao')) return 0;
-								return [0,hastarget?target.num('he')/2:0];
-							}
-							if(target.num('h','shan')&&target.num('h')>2){
-								if(!target.skills.contains('guidao')) return 0;
-								return [0,hastarget?target.num('h')/4:0];
-							}
-							if(target.num('h')>3||(be&&target.num('h')>=2)){
-								return [0,0];
-							}
-							if(target.num('h')==0){
-								return [1.5,0];
-							}
-							if(target.num('h')==1&&!be){
-								return [1.2,0];
-							}
-							if(!target.skills.contains('guidao')) return [1,0.05];
-							return [1,Math.min(0.5,(target.num('h')+be)/4)];
-						}
-					}
-				}
-			}
-		},
-		shensu:{
-			group:['shensu1','shensu2']
-		},
-		shensu1:{
-			audio:2,
-			trigger:{player:'phaseBegin'},
-			direct:true,
-			content:function(){
-				"step 0"
-				player.addSkill('shensu3');
-				var check= player.num('h')>2;
-				player.chooseTarget('是否发动【神速】？',function(card,player,target){
-					if(player==target) return false;
-					return player.canUse({name:'sha'},target);
-				}).ai=function(target){
-					if(!check) return 0;
-					return ai.get.effect(target,{name:'sha'},_status.event.player);
-				}
-				"step 1"
-				if(result.bool){
-					player.logSkill('shensu1',result.targets);
-					player.useCard({name:'sha'},result.targets[0],false);
-					player.skip('phaseJudge');
-					player.skip('phaseDraw');
-				}
-				player.removeSkill('shensu3');
-			}
-		},
-		shensu2:{
-			audio:2,
-			trigger:{player:'phaseUseBefore'},
-			direct:true,
-			filter:function(event,player){
-				return player.num('he',{type:'equip'})>0;
-			},
-			content:function(){
-				"step 0"
-				player.addSkill('shensu3');
-				var check=player.num('h')<=player.hp;
-				player.chooseCardTarget({
-					prompt:'是否发动【神速】？',
-					filterCard:function(card){
-						return get.type(card)=='equip'
-					},
-					position:'he',
-					filterTarget:function(card,player,target){
-						if(player==target) return false;
-						return player.canUse({name:'sha'},target);
-					},
-					ai1:function(card){
-						if(!check) return 0;
-						return 6-ai.get.value(card);
-					},
-					ai2:function(target){
-						if(!check) return 0;
-						return ai.get.effect(target,{name:'sha'},_status.event.player);
-					}
-				});
-				"step 1"
-				if(result.bool){
-					player.logSkill('shensu2',result.targets);
-					player.discard(result.cards[0]);
-					player.useCard({name:'sha'},result.targets[0]);
-					trigger.untrigger();
-					trigger.finish();
-				}
-				player.removeSkill('shensu3');
-			}
-		},
-		shensu3:{
-			mod:{
-				targetInRange:function(card,player,target,now){
-					return true;
-				}
-			},
-		},
-		jushou:{
-			audio:true,
-			trigger:{player:'phaseEnd'},
-			content:function(){
-				player.turnOver();
-				player.draw(3);
-			}
-		},
-		liegong:{
-			audio:2,
-			trigger:{player:'shaBegin'},
-			filter:function(event,player){
-				var length=event.target.num('h');
-				return (length>=player.hp||length<=get.attackRange(player));
-			},
-			content:function(){
-				trigger.directHit=true;
-			}
-		},
-		kuanggu:{
-			audio:2,
-			trigger:{source:'damageEnd'},
-			forced:true,
-			filter:function(event,player){
-				return get.distance(player,event.player)<=1;
-			},
-			content:function(){
-				player.recover(trigger.num);
-			}
-		},
-		tianxiang:{
-			audio:2,
-			trigger:{player:'damageBefore'},
-			direct:true,
-			filter:function(event,player){
-				return player.num('h',{suit:'heart'})>0&&event.num>0;
-			},
-			content:function(){
-				"step 0"
-				player.chooseCardTarget({
-					filterCard:function(card){
-						return get.suit(card)=='heart';
-					},
-					filterTarget:function(card,player,target){
-						return player!=target;
-					},
-					ai1:function(card){
-						return 10-ai.get.value(card);
-					},
-					ai2:function(target){
-						var att=ai.get.attitude(player,target);
-						if(trigger.num>1){
-							if(target.maxHp>5&&target.hp>1) return -att/10;
-							return -att;
-						}
-						var eff=ai.get.damageEffect(target,trigger.source,target,trigger.nature);
-						if(att==0) return 0.1;
-						if(eff>=0&&trigger.num==1){
-							return att;
-						}
-						if(target.hp==target.maxHp) return -att;
-						if(target.hp==1){
-							if(target.maxHp<=4&&!target.hasSkillTag('maixie')){
-								if(target.maxHp<=3){
-									return -att;
-								}
-								return -att/2;
-							}
-							return 0;
-						}
-						if(target.hp==target.maxHp-1){
-							if(target.hp>2||target.hasSkillTag('maixie')) return att/5;
-							if(att>0) return 0.02;
-							return 0.05;
-						}
-						return att/2;
-					},
-					prompt:'天香：弃置一张红桃牌转移伤害'
-				});
-				"step 1"
-				if(result.bool){
-					player.logSkill('tianxiang',result.targets);
-					trigger.untrigger();
-					trigger.player=result.targets[0];
-					trigger.player.addSkill('tianxiang2');
-					player.discard(result.cards[0]);
-				}
-				else{
-					event.finish();
-				}
-				"step 2"
-				trigger.trigger('damageBefore');
-			},
-			ai:{
-				effect:{
-					target:function(card,player,target){
-						if(player.skills.contains('jueqing')) return;
-						if(get.tag(card,'damage')&&target.num('h')>1) return 0.7;
-					}
-				},
-				threaten:function(player,target){
-					if(target.num('h')==0) return 2;
-				}
-			}
-		},
-		tianxiang2:{
-			trigger:{player:['damageAfter','damageCancelled']},
-			forced:true,
-			popup:false,
-			audio:false,
-			content:function(){
-				if(player.hp<player.maxHp) player.draw(player.maxHp-player.hp);
-				player.removeSkill('tianxiang2');
-				player.popup('tianxiang');
-			}
-		},
-		hongyan:{
-			mod:{
-				suit:function(card,suit){
-					if(suit=='spade') return 'heart';
-				}
-			}
-		},
-		buqu:{
-			audio:2,
-			trigger:{player:'dieBefore'},
-			forced:true,
-			filter:function(event,player){return player.maxHp>0},
-			content:function(){
-				"step 0"
-				event.card=get.cards()[0];
-				if(player.storage.buqu==undefined) player.storage.buqu=[];
-				player.storage.buqu.push(event.card);
-				game.addVideo('storage',player,['buqu',get.cardsInfo(player.storage.buqu),'cards']);
-				player.showCards(player.storage.buqu,'不屈')
-				game.log(player,'的不屈牌为',player.storage.buqu);
-				player.markSkill('buqu');
-				"step 1"
-				for(var i=0;i<player.storage.buqu.length-1;i++){
-					if(get.number(event.card)&&get.number(event.card)==get.number(player.storage.buqu[i])) return;
-				}
-				trigger.untrigger();
-				trigger.finish();
-				player.hp=0;
-			},
-			mod:{
-				maxHandcard:function(player){
-					if(player.storage.buqu&&player.storage.buqu.length) return player.storage.buqu.length;
-				}
-			},
-			intro:{
-				content:'cards',
-				onunmark:function(storage,player){
-					if(storage&&storage.length){
-						player.$throw(storage);
-						for(var i=0;i<storage.length;i++){
-							ui.discardPile.appendChild(storage[i]);
-						}
-						delete player.storage.buqu;
-					}
-				}
-			}
-		},
-		fenji:{
-			audio:2,
-			trigger:{global:'discardAfter'},
-			filter:function(event){
-				if(_status.currentPhase!=event.player){
-					for(var i=0;i<event.cards.length;i++){
-						if(event.cards[i].original=='h') return true;
-					}
-				}
-				return false;
-			},
-			check:function(event,player){
-				return ai.get.attitude(player,event.player)>2;
-			},
-			content:function(){
-				"step 0"
-				player.loseHp();
-				"step 1"
-				trigger.player.draw(2);
-			},
-		},
-		leiji:{
-			audio:2,
-			trigger:{player:'respond'},
-			filter:function(event,player){
-				return event.card.name=='shan';
-			},
-			direct:true,
-			content:function(){
-				"step 0";
-				player.chooseTarget('是否发动雷击？').ai=function(target){
-					return ai.get.damageEffect(target,player,player);
-				};
-				"step 1"
-				if(result.bool){
-					player.logSkill('leiji',result.targets,'thunder');
-					event.target=result.targets[0];
-					event.target.judge(function(card){
-						if(get.suit(card)=='spade') return -4;
-						return 0;
-					});
-				}
-				else{
-					event.finish();
-				}
-				"step 2"
-				if(result.bool==false){
-					event.target.damage(2,'thunder');
-				}
-			},
-			ai:{
-				mingzhi:false,
-				effect:{
-					target:function(card,player,target,current){
-						if(get.tag(card,'respondShan')){
-							var hastarget=false;
-							for(var i=0;i<game.players.length;i++){
-								if(ai.get.attitude(target,game.players[i])<0){
-									hastarget=true;break;
-								}
-							}
-							if(target.num('h','shan')&&target.num('e',{suit:'spade'})){
-								return [0,hastarget?target.num('he')/2:0];
-							}
-							if(target.num('h','shan')){
-								return [1,hastarget?target.num('he')/2:0];
-							}
-							return [1,target.num('h')/4];
-						}
-					}
-				}
-			}
-		},
-		guidao:{
-			audio:2,
-			trigger:{global:'judge'},
-			filter:function(event,player){
-				return player.num('he',{color:'black'})>0;
-			},
-			direct:true,
-			content:function(){
-				"step 0"
-				player.chooseCard(get.translation(trigger.player)+'的'+(trigger.judgestr||'')+'判定为'+
-				get.translation(trigger.player.judging[0])+'，是否发动【鬼道】？','he',function(card){
-					return get.color(card)=='black';
-				}).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('guidao');
-					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
-				}
-			}
-		},
-		guhuo:{
-			trigger:{player:'phaseBegin'},
-			forced:true,
-			content:function(){
-				player.draw();
-				player.chooseToDiscard('hej',true).ai=ai.get.disvalue;
-			},
-			ai:{
-				effect:{
-					target:function(card){
-						if(get.type(card)=='delay') return [0,1];
-					}
-				}
-			}
-		},
-		huangtian:{
-			unique:true,
-			global:'huangtian2'
-		},
-		huangtian2:{
-			audio:2,
-			enable:'phaseUse',
-			discard:false,
-			line:true,
-			prepare:function(cards,player,targets){
-				player.$give(cards,targets[0]);
-			},
-			filter:function(event,player){
-				if(!game.zhu) return false;
-				if(!game.zhu.isZhu) return false;
-				return (player!=game.zhu&&game.zhu.skills.contains('huangtian')&&player.group=='qun')
-			},
-			filterCard:function(card){
-				return (card.name=='shan'||card.name=='shandian')
-			},
-			filterTarget:function(card,player,target){
-				return target==game.zhu;
-			},
-			usable:1,
-			forceaudio:true,
-			content:function(){
-				target.gain(cards);
-			},
-			ai:{
-				expose:0.3,
-				order:10,
-				result:{
-					target:5
-				}
-			}
-		}
-	},
-	translate:{
-		xiahouyuan:'夏侯渊',
-		caoren:'曹仁',
-		huangzhong:'黄忠',
-		sp_zhangjiao:'张角',
-		weiyan:'魏延',
-		xiaoqiao:'小乔',
-		zhoutai:'周泰',
-		zhangjiao:'张角',
-		spzhangjiao:'张角',
-		yuji:'于吉',
-		shensu:'神速',
-		shensu1:'神速',
-		shensu2:'神速',
-		jushou:'据守',
-		liegong:'烈弓',
-		kuanggu:'狂骨',
-		tianxiang:'天香',
-		hongyan:'红颜',
-		buqu:'不屈',
-		leiji:'雷击',
-		spleiji:'新雷击',
-		guidao:'鬼道',
-		huangtian:'黄天',
-		huangtian2:'黄天',
-		guhuo:'蛊惑',
-		fenji:'奋激',
-		diyleiji:'雷击',
-		diyleiji_info:'每当你使用或打出一张【闪】，可令任意一名角色进行一次判定，若结果为梅花，其受到一点雷电伤害，然后你回复一点体力；若结果为黑桃，其受到两点雷电伤害',
-		tiangong:'天公',
-		tiangong2:'天公',
-		tiangong_info:'锁定技，你防止即将受到的雷电伤害，每当你造成一次雷电伤害，你摸一张牌',
-		shensu_info:
-		'你可以跳过摸牌阶段，或跳过出牌阶段并弃置一张装备牌，'+
-		'若如此则视为对任意一名使用一张【杀】',
-		jushou_info:
-		'回合结束阶段，你可以将武将牌翻页并摸3张牌',
-		liegong_info:
-		'当你使用【杀】时，若目标的手牌数大于等于你的体力值，或小于等于你的攻击范围，你可令此【杀】不能闪避',
-		kuanggu_info:
-		'锁定技，每当你造成一点伤害，若受伤害角色与你的距离不大于1，你回复一点体力',
-		tianxiang_info:
-		'当你即将受到伤害时，你可以弃置一张红桃牌将伤害转移给任意一名其他角色，然后该角色摸x张牌，x为其已损失体力值',
-		hongyan_info:
-		'锁定技，你的黑桃牌均视为红桃',
-		buqu_info:
-		'锁定技，每当你扣减1点体力后，若你当前的体力值为0，你可以将牌堆顶的一张牌置于你的武将牌上，'+
-		'称为“创”，若所有“创”的点数均不同，你不会死亡。你的手牌上限为“创”的个数',
-		leiji_info:
-		'每当你使用或打出一张【闪】，可令任意一名角色进行一次判定，若结果为黑桃，其受到两点雷电伤害',
-		spleiji_info:
-		'每当你使用或打出一张【闪】，可令任意一名角色进行一次判定，若结果为黑色，其受到一点雷电伤害，然后你回复一点体力',
-		guidao_info:
-		'任意一名角色的判定生效前，你可以打出一张黑色牌替换之',
-		huangtian_info:
-		'主公技，群雄角色可在他们各自的回合里给你一张【闪】或【闪电】。',
-		guhuo_info:
-		'锁定技，回合开始阶段，你摸一张牌并弃置区域内的一张牌',
-		fenji_info:
-		'每当一名角色的手牌于回合外被弃置时，你可以失去1点体力，然后该角色摸两张牌。'
-	},
-}

character/woods.js

@@ -1,786 +0,0 @@
-'use strict';
-character.woods={
-	character:{
-		menghuo:['male','shu',4,['huoshou','zaiqi']],
-		zhurong:['female','shu',4,['juxiang','lieren']],
-		caopi:['male','wei',3,['xingshang','fangzhu','songwei'],['zhu']],
-		xuhuang:['male','wei',4,['duanliang']],
-		lusu:['male','wu',3,['haoshi','dimeng']],
-		sunjian:['male','wu',4,['yinghun']],
-		dongzhuo:['male','qun',8,['jiuchi','roulin','benghuai','baonue'],['zhu']],
-		jiaxu:['male','qun',3,['luanwu','wansha','weimu']],
-	},
-	perfectPair:{
-		menghuo:['zhurong']
-	},
-	skill:{
-		huoshou:{
-			locked:true,
-			group:['huoshou1','huoshou2'],
-			ai:{
-				effect:{
-					target:function(card,player,target){
-						if(card.name=='nanman') return 0;
-					}
-				}
-			}
-		},
-		huoshou1:{
-			audio:2,
-			trigger:{target:'useCardToBefore'},
-			forced:true,
-			priority:15,
-			filter:function(event,player){
-				return (event.card.name=='nanman');
-			},
-			content:function(){
-				trigger.untrigger();
-				trigger.finish();
-			},
-		},
-		huoshou2:{
-			trigger:{global:'damageBefore'},
-			forced:true,
-			filter:function(event,player){
-				return (event.card&&event.card.name=='nanman');
-			},
-			content:function(){
-				trigger.source=player;
-			}
-		},
-		zaiqi:{
-			audio:2,
-			trigger:{player:'phaseDrawBefore'},
-			filter:function(event,player){
-				return player.hp<player.maxHp;
-			},
-			check:function(event,player){
-				if(player.maxHp-player.hp<2){
-					return false;
-				}
-				else if(player.maxHp-player.hp==2){
-					return player.num('h')>=2;
-				}
-				return true;
-			},
-			content:function(){
-				"step 0"
-				trigger.untrigger();
-				trigger.finish();
-				event.cards=get.cards(player.maxHp-player.hp);
-				player.showCards(event.cards);
-				"step 1"
-				var num=0;
-				for(var i=0;i<event.cards.length;i++){
-					if(get.suit(event.cards[i])=='heart'){
-						num++;
-						ui.discardPile.appendChild(event.cards[i]);
-						event.cards.splice(i--,1);
-					}
-				}
-				if(num){
-					player.recover(num);
-				}
-				"step 2"
-				if(event.cards.length){
-					player.gain(event.cards);
-					player.$gain2(event.cards);
-					game.delay();
-				}
-			},
-			ai:{
-				threaten:function(player,target){
-					if(target.hp==1) return 2;
-					if(target.hp==2) return 1.5;
-					return 1;
-				},
-			}
-		},
-		juxiang:{
-			unique:true,
-			locked:true,
-			group:['juxiang1','juxiang2'],
-			ai:{
-				effect:{
-					target:function(card){
-						if(card.name=='nanman') return [0,1];
-					}
-				}
-			}
-		},
-		juxiang1:{
-			audio:2,
-			trigger:{target:'useCardToBefore'},
-			forced:true,
-			priority:15,
-			filter:function(event,player){
-				return (event.card.name=='nanman');
-			},
-			content:function(){
-				trigger.untrigger();
-				trigger.finish();
-			}
-		},
-		juxiang2:{
-			trigger:{global:'useCardAfter'},
-			forced:true,
-			filter:function(event,player){
-				return (event.card.name=='nanman'&&event.player!=player&&get.position(event.card)=='d'&&get.itemtype(event.card)=='card');
-			},
-			content:function(){
-				player.gain(trigger.card);
-				player.$gain2(trigger.card);
-			}
-		},
-		lieren:{
-			audio:2,
-			trigger:{source:'damageEnd'},
-			filter:function(event,player){
-				return (event.card&&event.card.name=='sha'&&
-					event.player.classList.contains('dead')==false&&
-					event.player.num('h')&&player.num('h'));
-			},
-			check:function(event,player){
-				return ai.get.attitude(player,event.player)<0&&player.num('h')>1;
-			},
-			priority:5,
-			content:function(){
-				"step 0"
-				player.chooseToCompare(trigger.player);
-				"step 1"
-				if(result.bool&&trigger.player.num('he')){
-					player.gainPlayerCard(trigger.player,true,'he');
-				}
-			}
-		},
-		xingshang:{
-			audio:2,
-			unique:true,
-			gainable:true,
-			trigger:{global:'dieEnd'},
-			priority:5,
-			filter:function(event){
-				return event.cards.length>0
-			},
-			content:function(){
-				"step 0"
-				player.gain(trigger.playerCards);
-				player.$draw(trigger.playerCards);
-				game.delay();
-				"step 1"
-				for(var i=0;i<trigger.playerCards.length;i++){
-					trigger.cards.remove(trigger.playerCards[i]);
-				}
-				trigger.playerCards.length=0;
-			}
-		},
-		fangzhu:{
-			audio:2,
-			trigger:{player:'damageEnd'},
-			direct:true,
-			content:function(){
-				"step 0"
-				player.chooseTarget('是否发动【放逐】？',function(card,player,target){
-					return player!=target
-				}).ai=function(target){
-					var player=_status.event.player;
-					if(ai.get.attitude(_status.event.player,target)==0) return 0;
-					if(ai.get.attitude(_status.event.player,target)>0){
-						if(target.classList.contains('turnedover')) return 1000-target.num('h');
-						if(player.maxHp-player.hp<3) return -1;
-						return 100-target.num('h');
-					}
-					else{
-						if(target.classList.contains('turnedover')) return -1;
-						if(player.maxHp-player.hp>=3) return -1;
-						return 1+target.num('h');
-					}
-				}
-				"step 1"
-				if(result.bool){
-					player.logSkill('fangzhu',result.targets);
-					result.targets[0].draw(player.maxHp-player.hp);
-					result.targets[0].turnOver();
-				}
-			},
-			ai:{
-				maixie:true,
-				effect:{
-					target:function(card,player,target){
-						if(get.tag(card,'damage')){
-							if(player.skills.contains('jueqing')) return [1,-2];
-							if(target.hp<=1) return;
-							var hastarget=false;
-							var hasfriend=false;
-							var turnfriend=false;
-							for(var i=0;i<game.players.length;i++){
-								if(ai.get.attitude(target,game.players[i])<0&&!game.players[i].isTurnedOver()){
-									hastarget=true;
-								}
-								if(ai.get.attitude(target,game.players[i])>0&&game.players[i].isTurnedOver()){
-									hastarget=true;
-									turnfriend=true;
-								}
-								if(game.players[i]!=target&&ai.get.attitude(game.players[i],target)>=0){
-									hasfriend=true;
-								}
-							}
-							if(ai.get.attitude(player,target)>0&&!hastarget) return;
-							if(!hasfriend) return;
-							if(turnfriend||target.hp==target.maxHp) return [0.5,1];
-							if(target.hp>1) return [1,1];
-						}
-					}
-				}
-			}
-		},
-		songwei:{
-			unique:true,
-			global:'songwei2',
-		},
-		songwei2:{
-			audio:2,
-			forceaudio:true,
-			trigger:{player:'judgeEnd'},
-			filter:function(event,player){
-				if(!game.zhu) return false;
-				if(!game.zhu.isZhu) return false;
-				return (player!=game.zhu&&game.zhu.skills.contains('songwei')&&player.group=='wei'&&get.color(event.result.card)=='black');
-			},
-			check:function(event,player){
-				return ai.get.attitude(player,game.zhu)>0;
-			},
-			content:function(){
-				game.zhu.draw();
-			}
-		},
-		duanliang:{
-			group:['duanliang1','duanliang2'],
-			ai:{
-				threaten:1.2
-			}
-		},
-		duanliang1:{
-			audio:2,
-			enable:'chooseToUse',
-			filterCard:function(card){
-				if(get.type(card)=='trick') return false;
-				if(get.type(card)=='delay') return false;
-				return get.color(card)=='black';
-			},
-			position:'he',
-			viewAs:{name:'bingliang'},
-			prompt:'将一黑色的基本牌或装备牌当兵粮寸断使用',
-			check:function(card){return 6-ai.get.value(card)},
-			ai:{
-				order:9
-			}
-		},
-		duanliang2:{
-			mod:{
-				targetInRange:function(card,player,target){
-					if(card.name=='bingliang'){
-						if(get.distance(player,target)<=2) return true;
-					}
-				}
-			}
-		},
-		haoshi:{
-			audio:2,
-			trigger:{player:'phaseDrawBegin'},
-			threaten:1.4,
-			check:function(event,player){
-				if(player.num('h')<=1) return true;
-				var min=[];
-				var temp=player.next.num('h');
-				for(var i=0;i<game.players.length;i++){
-					if(game.players[i]!=player&&game.players[i].num('h')<temp){
-						temp=game.players[i].num('h');
-					}
-				}
-				for(var i=0;i<game.players.length;i++){
-					if(game.players[i]!=player&&game.players[i].num('h')==temp){
-						min.push(game.players[i]);
-					}
-				}
-				for(var i=0;i<min.length;i++){
-					if(ai.get.attitude(player,min[i])>0) return true;
-				}
-				return false;
-			},
-			content:function(){
-				trigger.num+=2;
-				player.addSkill('haoshi2');
-			},
-			ai:{
-				threaten:2
-			}
-		},
-		haoshi2:{
-			trigger:{player:'phaseDrawEnd'},
-			forced:true,
-			popup:false,
-			audio:false,
-			content:function(){
-				"step 0"
-				player.removeSkill('haoshi2');
-				if(player.num('h')<=5){
-					event.finish();
-					return;
-				}
-				var temp=player.next.num('h');
-				for(var i=0;i<game.players.length;i++){
-					if(game.players[i]!=player&&game.players[i].num('h')<temp){
-						temp=game.players[i].num('h');
-					}
-				}
-				player.chooseCardTarget({
-					selectCard:Math.floor(player.num('h')/2),
-					filterTarget:function(card,player,target){
-						return target.num('h')==temp;
-					},
-					forced:true,
-					ai2:function(target){
-						return ai.get.attitude(player,target);
-					}
-				});
-				"step 1"
-				if(result.targets&&result.targets[0]){
-					result.targets[0].gain(result.cards);
-					player.$give(result.cards.length,result.targets[0]);
-				}
-			}
-		},
-		dimeng:{
-			audio:2,
-			enable:'phaseUse',
-			usable:1,
-			position:'he',
-			filterCard:true,
-			selectCard:[0,Infinity],
-			selectTarget:2,
-			filterTarget:function(card,player,target){
-				if(player==target) return false;
-				if(ui.selected.targets.length==0) return true;
-				return (Math.abs(ui.selected.targets[0].num('h')-target.num('h'))==
-					ui.selected.cards.length);
-			},
-			multitarget:true,
-			content:function(){
-				'step 0'
-				event.cards0=targets[0].get('h');
-				event.cards1=targets[1].get('h');
-				targets[0].lose(event.cards0,ui.special);
-				targets[1].lose(event.cards1,ui.special);
-				'step 1'
-				targets[0].gain(event.cards1);
-				targets[1].gain(event.cards0);
-				targets[0].$give(event.cards0.length,targets[1]);
-				targets[1].$give(event.cards1.length,targets[0]);
-			},
-			check:function(card){
-				var list=[],player=_status.event.player;
-				var num=player.num('he');
-				var count;
-				for(var i=0;i<game.players.length;i++){
-					if(game.players[i]!=player&&ai.get.attitude(player,game.players[i])>3) list.push(game.players[i]);
-				}
-				list.sort(function(a,b){
-					return a.num('h')-b.num('h');
-				});
-				if(list.length==0) return -1;
-				var from=list[0];
-				list.length=0;
-
-				for(var i=0;i<game.players.length;i++){
-					if(game.players[i]!=player&&ai.get.attitude(player,game.players[i])<1) list.push(game.players[i]);
-				}
-				if(list.length==0) return -1;
-				list.sort(function(a,b){
-					return b.num('h')-a.num('h');
-				});
-				if(from.num('h')>=list[0].num('h')) return -1;
-				for(var i=0;i<list.length&&from.num('h')<list[i].num('h');i++){
-					if(list[i].num('h')-from.num('h')<=num){
-						count=list[i].num('h')-from.num('h');break;
-					}
-				}
-				if(count<2&&from.num('h')>=2) return -1;
-				if(ui.selected.cards.length<count) return 11-ai.get.value(card);
-				return -1;
-			},
-			ai:{
-				order:6,
-				threaten:3,
-				expose:0.9,
-				result:{
-					target:function(player,target){
-						var list=[];
-						var num=player.num('he');
-						if(ui.selected.targets.length==0){
-							for(var i=0;i<game.players.length;i++){
-								if(game.players[i]!=player&&ai.get.attitude(player,game.players[i])>3) list.push(game.players[i]);
-							}
-							list.sort(function(a,b){
-								return a.num('h')-b.num('h');
-							});
-							if(target==list[0]) return ai.get.attitude(player,target);
-							return -ai.get.attitude(player,target);
-						}
-						else{
-							var from=ui.selected.targets[0];
-							for(var i=0;i<game.players.length;i++){
-								if(game.players[i]!=player&&ai.get.attitude(player,game.players[i])<1) list.push(game.players[i]);
-							}
-							list.sort(function(a,b){
-								return b.num('h')-a.num('h');
-							});
-							if(from.num('h')>=list[0].num('h')) return -ai.get.attitude(player,target);
-							for(var i=0;i<list.length&&from.num('h')<list[i].num('h');i++){
-								if(list[i].num('h')-from.num('h')<=num){
-									var count=list[i].num('h')-from.num('h');
-									if(count<2&&from.num('h')>=2) return -ai.get.attitude(player,target);
-									if(target==list[i]) return ai.get.attitude(player,target);
-									return -ai.get.attitude(player,target);
-								}
-							}
-						}
-					}
-				}
-			}
-		},
-		yinghun:{
-			audio:2,
-			trigger:{player:'phaseBegin'},
-			filter:function(event,player){
-				return player.hp<player.maxHp;
-			},
-			direct:true,
-			content:function(){
-				"step 0"
-				player.chooseTarget(function(card,player,target){
-					return player!=target;
-				}).ai=function(target){
-					if(player.maxHp-player.hp==1&&target.num('he')==0){
-						return 0;
-					}
-					if(ai.get.attitude(_status.event.player,target)>0){
-						return 10+ai.get.attitude(_status.event.player,target);
-					}
-					if(player.maxHp-player.hp==1){
-						return -1;
-					}
-					return 1;
-				}
-				"step 1"
-				if(result.bool){
-					player.logSkill('yinghun',result.targets);
-					event.target=result.targets[0];
-					player.chooseControl('yinghun_true','yinghun_false',function(event,player){
-						if(ai.get.attitude(player,event.target)>0) return 'yinghun_true';
-						return 'yinghun_false';
-					})
-				}
-				else{
-					event.finish();
-				}
-				"step 2"
-				if(result.control=='yinghun_true'){
-					event.target.draw(player.maxHp-player.hp);
-					event.target.chooseToDiscard(true,'he');
-				}
-				else{
-					event.target.draw();
-					event.target.chooseToDiscard(player.maxHp-player.hp,true,'he');
-				}
-			},
-			ai:{
-				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(target.maxHp<=3) return;
-						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];
-					}
-				}
-			}
-		},
-		jiuchi:{
-			audio:2,
-			enable:'chooseToUse',
-			filterCard:function(card){
-				return get.suit(card)=='spade';
-			},
-			viewAs:{name:'jiu'},
-			viewAsFilter:function(player){
-				if(!player.num('h',{suit:'spade'})) return false;
-			},
-			prompt:'将一张黑桃手牌当酒使用',
-			check:function(card){
-				if(_status.event.type=='dying') return 1;
-				return 4-ai.get.value(card);
-			},
-			ai:{
-				skillTagFilter:function(player){
-					return player.num('h',{suit:'spade'})>0;
-				},
-				threaten:1.5,
-				save:true,
-			}
-		},
-		roulin:{
-			audio:2,
-			trigger:{player:'shaBegin',target:'shaBegin'},
-			forced:true,
-			filter:function(event,player){
-				if(event.directHit) return false;
-				if(player==event.player){
-					return event.target.sex=='female';
-				}
-				return event.player.sex=='female';
-			},
-			check:function(event,player){
-				return player==event.player;
-			},
-			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;
-				}
-			}
-		},
-		benghuai:{
-			audio:4,
-			trigger:{player:'phaseEnd'},
-			forced:true,
-			check:function(){
-				return false;
-			},
-			filter:function(event,player){
-				for(var i=0;i<game.players.length;i++){
-					if(game.players[i]!=player&&game.players[i].hp<player.hp) return true;
-				}
-				return false;
-			},
-			content:function(){
-				"step 0"
-				player.chooseControl('baonue_hp','baonue_maxHp',function(event,player){
-					if(player.hp<player.maxHp-1||player.hp<=2) return 'baonue_maxHp';
-					return 'baonue_hp';
-				});
-				"step 1"
-				if(result.control=='baonue_hp'){
-					player.loseHp();
-				}
-				else{
-					player.loseMaxHp();
-				}
-			},
-			ai:{
-				threaten:0.5
-			}
-		},
-		baonue:{
-			unique:true,
-			global:'baonue2'
-		},
-		baonue2:{
-			audio:2,
-			forceaudio:true,
-			trigger:{source:'damageEnd'},
-			filter:function(event,player){
-				if(!game.zhu) return false;
-				if(!game.zhu.isZhu) return false;
-				return (player!=game.zhu&&game.zhu.skills.contains('baonue')&&player.group=='qun')&&game.zhu.hp<game.zhu.maxHp;
-			},
-			check:function(event,player){
-				return ai.get.attitude(player,game.zhu)>0;
-			},
-			content:function(){
-				"step 0"
-				player.judge(function(card){
-					if(get.suit(card)=='spade') return 4;
-					return 0;
-				})
-				"step 1"
-				if(result.bool){
-					game.zhu.recover();
-				}
-			}
-		},
-		luanwu:{
-			audio:2,
-			unique:true,
-			enable:'phaseUse',
-			filter:function(event,player){
-				return !player.storage.luanwu;
-			},
-			init:function(player){
-				player.storage.luanwu=false;
-			},
-			mark:true,
-			intro:{
-				content:'limited'
-			},
-			skillAnimation:'epic',
-			animationColor:'thunder',
-			prepare:function(cards,player){
-				player.line(game.players);
-				for(var i=0;i<game.players.length;i++){
-					if(game.players[i]!=player){
-						game.players[i].animate('target');
-					}
-				}
-			},
-			content:function(){
-				"step 0"
-				player.unmarkSkill('luanwu')
-				player.storage.luanwu=true;
-				event.current=player.next;
-				"step 1"
-				event.current.animate('target');
-				event.current.chooseToUse({name:'sha'},function(card,player,target){
-					if(player==target) return false;
-					if(get.distance(player,target)<=1) return true;
-					for(var i=0;i<game.players.length;i++){
-						if(game.players[i]==player) continue;
-						if(get.distance(player,game.players[i])<get.distance(player,target)) return false;
-					}
-					return true;
-				})
-				"step 2"
-				if(result.bool==false) event.current.loseHp();
-				if(event.current.next!=player){
-					event.current=event.current.next;
-					game.delay(0.5);
-					event.goto(1);
-				}
-			},
-			ai:{
-				order:1,
-				result:{
-					player:function(player){
-						if(lib.config.mode=='identity'&&game.zhu.isZhu&&player.identity=='fan'){
-							if(game.zhu.hp==1&&game.zhu.num('h')<=2) return 1;
-						}
-						var num=0;
-						for(var i=0;i<game.players.length;i++){
-							var att=ai.get.attitude(player,game.players[i]);
-							if(att>0) att=1;
-							if(att<0) att=-1;
-							if(game.players[i]!=player&&game.players[i].hp<=3){
-								if(game.players[i].num('h')==0) num+=att/game.players[i].hp;
-								else if(game.players[i].num('h')==1) num+=att/2/game.players[i].hp;
-								else if(game.players[i].num('h')==2) num+=att/4/game.players[i].hp;
-							}
-							if(game.players[i].hp==1) num+=att*1.5;
-						}
-						// console.log(num);
-						if(player.hp==1){
-							return -num;
-						}
-						if(player.hp==2){
-							return -game.players.length/4-num;
-						}
-						return -game.players.length/3-num;
-					}
-				}
-			}
-		},
-		wansha:{
-			locked:true,
-			global:'wansha2'
-		},
-		wansha2:{
-			mod:{
-				cardSavable:function(card,player){
-					if(_status.currentPhase.skills.contains('wansha')&&_status.currentPhase!=player){
-						if(card.name=='tao'&&_status.dying!=player) return false;
-					}
-				}
-			}
-		},
-		weimu:{
-			mod:{
-				targetEnabled:function(card){
-					if((get.type(card)=='trick'||get.type(card)=='delay')&&
-						get.color(card)=='black') return false;
-				}
-			}
-		},
-	},
-	translate:{
-		zhurong:'祝融',
-		menghuo:'孟获',
-		caopi:'曹丕',
-		xuhuang:'徐晃',
-		lusu:'鲁肃',
-		sunjian:'孙坚',
-		dongzhuo:'董卓',
-		jiaxu:'贾诩',
-		huoshou:'祸首',
-		huoshou1:'祸首',
-		huoshou2:'祸首',
-		zaiqi:'再起',
-		juxiang:'巨象',
-		juxiang1:'巨象',
-		juxiang2:'巨象',
-		lieren:'烈刃',
-		xingshang:'行殇',
-		fangzhu:'放逐',
-		songwei:'颂威',
-		songwei2:'颂威',
-		duanliang:'断粮',
-		duanliang1:'断粮',
-		haoshi:'好施',
-		dimeng:'缔盟',
-		yinghun:'英魂',
-		yinghun_true:'摸X弃1',
-		yinghun_false:'摸1弃X',
-		jiuchi:'酒池',
-		roulin:'肉林',
-		benghuai:'崩坏',
-		baonue:'暴虐',
-		baonue2:'暴虐',
-		baonue_hp:'体力',
-		baonue_maxHp:'体力上限',
-		luanwu:'乱武',
-		wansha:'完杀',
-		weimu:'帷幕',
-		huoshou_info:'【南蛮入侵】对你无效；你是任何【南蛮入侵】造成伤害的来源。',
-		zaiqi_info:'摸牌阶段，若你已受伤，你可以放弃摸牌并展示牌堆顶的X张牌，X为你已损失的体力值，其中每有一张♥牌，你回复1点体力，然后弃掉这些♥牌，将其余的牌收入手牌。',
-		juxiang_info:'南蛮入侵】对你无效；若其他角色使用的【南蛮入侵】在结算完时进入弃牌堆，你立即获得它。',
-		lieren_info:'你每使用【杀】造成一次伤害，可与受到该伤害的角色拼点；若你赢，你获得对方的一张牌。',
-		xingshang_info:'你可以立即获得死亡角色的所有牌。',
-		fangzhu_info:'你每受到一次伤害，可令除你以外的任一角色补X张牌，X为你已损失的体力值，然后该角色将其武将牌翻面。',
-		songwei_info:'主公技，其他魏势力的角色的判定牌结果为♠或♣且失效后，可以让你摸一张牌。',
-		duanliang_info:'出牌阶段，你可以将你的任意一张♠或♣的基本牌或装备牌当【兵粮寸断】使用；你可以对与你距离2以内的角色使用【兵粮寸断】。',
-		haoshi_info:'摸牌阶段，你可以额外摸两张牌，若此时你的手牌数多于五张，你必须将一半(向下取整)的手牌交给场上除你外手牌数最少的一名角色。',
-		dimeng_info:'出牌阶段，你可以选择其他两名角色，你弃掉等同于这两名角色手牌数量之差的牌，然后交换他们的手牌，每回合限一次。',
-		yinghun_info:'回合开始阶段，若你已受伤，可选择一名其他角色执行下列两项中的一项： 1.摸X张牌，然后弃一张牌。 2.摸一张牌，然后弃X张牌。 X为你已损失的体力值，每回合限一次。',
-		jiuchi_info:'你可将你的任意一张♠手牌当【酒】使用。',
-		roulin_info:'你对女性角色、女性角色对你使用【杀】时，都需连续使用两张【闪】才能抵消。',
-		benghuai_info:'回合结束阶段，若你的体力不是全场最少的(或之一)，你须减1点体力或体力上限。',
-		baonue_info:'主公技，其他群雄角色每造成一次伤害，可进行一次判定，若为♠，你回复1点体力。',
-		luanwu_info:'出牌阶段，可令除你外的所有角色依次对与其距离最近的另一名角色使用一张【杀】，无法如此做者失去1点体力。',
-		wansha_info:'在你的回合，除你以外，只有处于濒死状态的角色才能使用【桃】。',
-		weimu_info:'你不能成为♠或♣锦囊的目标。',
-	},
-}

character/xianjian.js

@@ -50,7 +50,7 @@ character.xianjian={
 			trigger:{source:'damageBegin'},
 			forced:true,
 			filter:function(event){
-				return event.nature=='fire';
+				return event.nature=='fire'&&event.notLink();
 			},
 			content:function(){
 				trigger.num++;

character/yijiang.js

@@ -62,6 +62,8 @@ character.yijiang={
 		quancong:['male','wu',4,['yaoming']],
 		gongsunyuan:['male','qun',4,['huaiyi']],
 		guotufengji:['male','qun',3,['jigong','shifei']],
+
+		xin_yujin:['male','wei',4,['jieyue']],
 	},
 	perfectPair:{
 		wuguotai:['sunjian','sunshangxiang'],
@@ -80,6 +82,119 @@ character.yijiang={
 		guanping:['guanyu'],
 	},
 	skill:{
+		jieyue:{
+			group:'jieyue1'
+		},
+		jieyue1:{
+			audio:2,
+			trigger:{player:'phaseEnd'},
+			direct:true,
+			content:function(){
+				'step 0'
+				player.chooseCardTarget({
+					filterTarget:function(card,player,target){
+						return target!=player&&target.num('he')>0;
+					},
+					filterCard:true,
+					ai1:function(card){
+						return 7-ai.get.useful(card);
+					},
+					ai2:function(target){
+						return 1-ai.get.attitude(player,target);
+					},
+					prompt:'是否发动【节钺】？'
+				});
+				'step 1'
+				if(result.bool){
+					player.logSkill('jieyue1',result.targets);
+					player.discard(result.cards);
+					var target=result.targets[0];
+					event.target=target;
+					target.chooseCard('将一张牌置于'+get.translation(player)+'的武将牌上，或令其弃置你的一张牌','he').ai=function(card){
+						if(ai.get.attitude(player,target)>0){
+							return 8-ai.get.value(card);
+						}
+						var nh=player.num('h');
+						if(nh<=2){
+							return 6-ai.get.value(card);
+						}
+						if(nh<=3){
+							return 2-ai.get.value(card);
+						}
+						return 0;
+					}
+				}
+				else{
+					event.finish();
+				}
+				'step 2'
+				if(result.bool&&result.cards&&result.cards.length){
+					event.target.$give(result.cards,player);
+					player.storage.jieyue2=result.cards[0];
+					event.target.lose(result.cards[0],ui.special);
+					player.syncStorage('jieyue2');
+					player.addSkill('jieyue2');
+				}
+				else if(event.target.num('he')){
+					player.discardPlayerCard(event.target,true);
+				}
+			},
+			ai:{
+				expose:0.1
+			}
+		},
+		jieyue2:{
+			mark:'card',
+			intro:{
+				content:'card'
+			},
+			audio:true,
+			enable:'chooseToUse',
+			filterCard:function(card){
+				return get.color(card)=='black';
+			},
+			viewAsFilter:function(player){
+				return player.num('h',{color:'black'})>0;
+			},
+			viewAs:{name:'wuxie'},
+			prompt:'将一张黑色手牌当无懈可击使用',
+			check:function(card){return 8-ai.get.value(card)},
+			threaten:1.2,
+			group:['jieyue3','jieyue4']
+		},
+		jieyue3:{
+			enable:['chooseToRespond'],
+			filterCard:function(card){
+				return get.color(card)=='red';
+			},
+			viewAs:{name:'shan'},
+			viewAsFilter:function(player){
+				if(!player.num('h',{color:'red'})) return false;
+			},
+			audio:true,
+			prompt:'将一张红色手牌当闪打出',
+			check:function(){return 1},
+			ai:{
+				respondShan:true,
+				skillTagFilter:function(player){
+					if(!player.num('h',{color:'red'})) return false;
+				},
+				result:{
+					target:function(card,player,target,current){
+						if(get.tag(card,'respondShan')&&current<0) return 0.8
+					}
+				}
+			}
+		},
+		jieyue4:{
+			trigger:{player:'phaseBegin'},
+			forced:true,
+			content:function(){
+				player.gain(player.storage.jieyue2,'gain2');
+				player.storage.jieyue2=null;
+				player.removeSkill('jieyue2');
+			}
+		},
 		jinjiu:{
 			mod:{
 				cardEnabled:function(card,player){
@@ -665,7 +780,10 @@ character.yijiang={
 						!trigger.player.skills.contains('fengnu')&&
 						!trigger.player.num('e','zhuge')){
 						var nh=trigger.player.num('h');
-						if(nh>=4){
+						if(player==trigger.player){
+							go=(player.num('h','sha')>0);
+						}
+						else if(nh>=4){
 							go=true;
 						}
 						else if(player.num('h','sha')){
@@ -5460,7 +5578,14 @@ character.yijiang={
 		hanhaoshihuan:'韩浩史涣',
 		chengpu:'程普',
 		gaoshun:'高顺',
+		xin_yujin:'新于禁',
 
+		jieyue:'节钺',
+		jieyue1:'节钺',
+		jieyue2:'节钺',
+		jieyue3:'节钺',
+		jieyue4:'节钺',
+		jieyue_info:'结束阶段开始时，你可以弃置一张手牌，然后令一名其他角色选择一项：将一张牌置于你的武将牌上；或令你弃置其一张牌。你武将牌上有牌时，你可以将红色手牌当【闪】、黑色的手牌当【无懈可击】使用或打出。准备阶段开始时，你获得你武将牌上的牌。',
 		xianzhen:'陷阵',
 		xianzhen_info:'出牌阶段，你可以与一名角色拼点。若你赢，你获得以下技能直到回合结束：无视与该角色的距离；无视防具且可使用任意数量的【杀】。若你没赢，你不能使用【杀】直到回合结束。每回合限一次',
 		jinjiu:'禁酒',

character/yxs.js

@@ -1646,7 +1646,7 @@ character.yxs={
 			trigger:{player:'recoverEnd'},
 			check:function(event,player){
 				if(event.parent.name=='taoyuan'&&event.parent.player==player){
-					console.log(1);return false;
+					return false;
 				}
 				var num=0;
 				var ef;

character/zhuogui.js

@@ -242,6 +242,9 @@ character.zhuogui={
                     result.targets[0].$give(1,player);
                     game.delay();
                 }
+            },
+            ai:{
+                threaten:1.7
             }
         },
         suoling:{

game/config.js

@@ -1,6 +1,6 @@
 window.config={
 	forbidai:['zuoci','caiwenji'],
-	forbidsingle:['menghuo','huanggai','caoren','machao','pangde','yanwen','xiahoudun','xuzhu','luxun',
+	forbidsingle:['menghuo','huanggai','machao','pangde','yanwen','xiahoudun','xuzhu','luxun',
 	'xuhuang','yujin','xiaoqiao','daqiao','zhangjiao','zhangbao'],
 	forbidall:['caocao','simayi','guanyu','zhangfei','zhaoyun','ganning','lvmeng','lvbu',
 	'xiahouyuan','huangzhong','weiyan','dianwei','gongsunzan','zhangjiao'],
@@ -8,7 +8,7 @@ window.config={
 	forbidstone:['zhugedan','pal_xuanxiao'],
 	forbidchess:['hetaihou','swd_kangnalishi'],
 	forbidboss:['caiwenji','gjqt_aruan','pal_xuanxiao','swd_hupo'],
-	forbiddouble:['zhugedan','swd_kangnalishi','swd_nicole','dongzhuo','wutugu','jg_simayi','hs_siwangzhiyi','hs_ronghejuren'],
+	forbiddouble:['zhugedan','swd_kangnalishi','dongzhuo','wutugu','jg_simayi','hs_siwangzhiyi','hs_ronghejuren','hs_shanlingjuren'],
 	layoutfixed:['chess'],
 	all:{
 		mode:['identity','guozhan','versus','boss','chess','stone'],
@@ -253,7 +253,7 @@ window.config={
 	sort:'type_sort',
 
 	cards:['standard','ex','extra','refresh'],
-	characters:['standard','wind','fire','woods','mountain','refresh','yijiang'],
+	characters:['standard','shenhua','refresh','yijiang'],
 	plays:[],
 	banned:[],
 	bannedcards:[],

game/game.js

@@ -16,16 +16,18 @@
 		dieClose:[]
 	};
 	var lib={
-		version:1.76,
+		version:1.77,
 		changeLog:[
-			'bug修复（捉鬼、导出武将）',
+			'新武将(SP)',
-			'配音支持引用文件名',
+			'志继、化身结算',
-			'挑战模式可关闭单人控制',
+			'提示样式修改',
-			'不同模式可单独设置禁将、禁卡',
+			'牌堆管理',
-			'自定义技能禁配',
+			'战棋1v1、对决4v4',
-			'战棋对战选项',
+			'年兽、守卫剑阁',
-			'炉石模式平衡调整',
+			'注1：年兽在挑战模式，守卫剑阁在对决模式菜单中的游戏模式里选',
-			'ctrl+shift+R重置游戏'
+			'注2：此版本去掉了diy捉鬼和剑阁武将包，未来将进入diy武将包',
+			'注3：此版本更改了手气卡代码，若要关闭需重新设置',
+			'注4：安卓版预计一周内更新'
 		],
 		configprefix:'noname_0.9_',
 		updates:[],
@@ -662,6 +664,20 @@
 							}
 						}
 					},
+					// popup_style:{
+					// 	name:'提示样式',
+					// 	init:'newstyle',
+					// 	item:{
+					// 		newstyle:'默认',
+					// 		old:'旧版'
+					// 	},
+					// 	unfrequent:true,
+					// },
+					show_card_prompt:{
+						name:'出牌显示卡牌名',
+						init:true,
+						unfrequent:true,
+					},
 					fold_card:{
 						name:'折叠手牌',
 						init:true,
@@ -1346,12 +1362,11 @@
 				name:'其它',
 				config:{
 					reset_game:{
-						name:'重置游戏',
+						name:'重置游戏设置',
 						onclick:function(){
 							var node=this;
 							if(node._clearing){
 								localStorage.clear();
-								if(indexedDB) indexedDB.deleteDatabase(lib.configprefix+'data');
 								game.reload();
 								return;
 							}
@@ -1370,6 +1385,30 @@
 						},
 						clear:true
 					},
+					reset_database:{
+						name:'重置自定义武将及录像',
+						onclick:function(){
+							var node=this;
+							if(node._clearing){
+								if(indexedDB) indexedDB.deleteDatabase(lib.configprefix+'data');
+								game.reload();
+								return;
+							}
+							node._clearing=true;
+							node.innerHTML='单击以确认 (3)';
+							setTimeout(function(){
+								node.innerHTML='单击以确认 (2)';
+								setTimeout(function(){
+									node.innerHTML='单击以确认 (1)';
+									setTimeout(function(){
+										node.innerHTML='重置自定义武将及录像';
+										delete node._clearing;
+									},1000);
+								},1000);
+							},1000);
+						},
+						clear:true
+					},
 					reset_hiddenpack:{
 						name:'重置隐藏扩展包',
 						onclick:function(){
@@ -1596,7 +1635,13 @@
 					},
 					change_card:{
 						name:'开启手气卡',
-						init:false,
+						init:'disabled',
+						item:{
+							disabled:'禁用',
+							once:'一次',
+							twice:'两次',
+							unlimited:'无限',
+						}
 					},
 					dierestart:{
 						name:'死亡后显示重来',
@@ -1826,7 +1871,13 @@
 					},
 					change_card:{
 						name:'开启手气卡',
-						init:false,
+						init:'disabled',
+						item:{
+							disabled:'禁用',
+							once:'一次',
+							twice:'两次',
+							unlimited:'无限',
+						}
 					},
 					dierestart:{
 						name:'死亡后显示重来',
@@ -1903,6 +1954,62 @@
 			versus:{
 				name:'对决',
 				config:{
+					update:function(config,map){
+						if(config.versus_mode=='four'){
+							map.change_choice.hide();
+							map.enable_all.show();
+							map.four_assign.show();
+						}
+						else{
+							map.change_choice.show();
+							map.enable_all.hide();
+							map.four_assign.hide();
+						}
+						if(config.versus_mode=='jiange'){
+							map.free_choose.show();
+						}
+						else{
+							map.free_choose.hide();
+						}
+					},
+					versus_mode:{
+						name:'游戏模式',
+						init:'standard',
+						item:{
+							standard:'标准',
+							jiange:'剑阁',
+							four:'<span style="display:inline-block;width:100%;text-align:center">4v4</span>'
+						},
+						restart:true,
+						frequent:true,
+					},
+					enable_all:{
+						name:'启用全部武将',
+						init:false,
+						frequent:true,
+						restart:true,
+					},
+					four_assign:{
+						name:'代替队友选将',
+						init:true,
+						frequent:true,
+						restart:true,
+					},
+					free_choose:{
+						name:'自由选将',
+						init:true,
+						frequent:true,
+						onclick:function(bool){
+							game.saveConfig('free_choose',bool,this._link.config.mode);
+							if(!ui.create.cheat2) return;
+							if(!_status.event.parent.showConfig&&!_status.event.showConfig) return;
+							if(!ui.cheat2&&get.config('free_choose')) ui.create.cheat2();
+							else if(ui.cheat2&&!get.config('free_choose')){
+								ui.cheat2.close();
+								delete ui.cheat2;
+							}
+						}
+					},
 					change_choice:{
 						name:'开启换将卡',
 						init:false,
@@ -2123,25 +2230,6 @@
 						clear:true,
 						frequent:true,
 					},
-					// battle_number:{
-					// 	name:'对战人数',
-					// 	init:'3',
-					// 	frequent:true,
-					// 	item:{
-					// 		'2':'2v2',
-					// 		'3':'3v3',
-					// 		'4':'4v4',
-					// 		'6':'6v6',
-					// 		'8':'8v8',
-					// 	},
-					// 	onclick:function(num){
-					// 		game.saveConfig('battle_number',num,this._link.config.mode);
-					// 		if(!_status.event.parent.showConfig&&!_status.event.showConfig) return;
-					// 		if(_status.event.parent.changeDialog){
-					// 			_status.event.parent.changeDialog();
-					// 		}
-					// 	},
-					// },
 					chess_treasure:{
 						name:'战场机关',
 						init:'0.2',
@@ -2168,27 +2256,22 @@
 					attack_move:{
 						name:'击退效果',
 						init:true,
-						// frequent:true,
 					},
 					show_distance:{
 						name:'显示距离',
 						init:true,
-						// frequent:true,
 					},
-					// chess_ordered:{
-					// 	name:'交替行动',
-					// 	init:true,
-					// 	// frequent:true,
-					// },
 					chess_character:{
 						name:'战棋武将',
 						init:true,
-						// frequent:true,
 					},
+					// chess_jiange:{
+					// 	name:'守卫剑阁',
+					// 	init:true,
+					// },
 					chess_card:{
 						name:'战棋卡牌',
 						init:true,
-						// frequent:true,
 					},
 					free_choose:{
 						name:'自由选将',
@@ -2400,6 +2483,9 @@
 			'<div style="margin:10px">明忠</div><ul style="margin-top:0"><li>本模式需要8名玩家进行游戏，使用的身份牌为：1主公、2忠臣、4反贼和1内奸。游戏开始时，每名玩家随机获得一个身份，由系统随机选择一名忠臣身份的玩家亮出身份（将忠臣牌正面朝上放在面前），其他身份（包括主公）的玩家不亮出身份。<li>'+
 			'首先由亮出身份的忠臣玩家随机获得六张武将牌，挑选一名角色，并将选好的武将牌展示给其他玩家。之后其余每名玩家随机获得三张武将牌，各自从其中挑选一张同时亮出<li>'+
 			'亮出身份牌的忠臣增加1点体力上限。角色濒死和死亡的结算及胜利条件与普通身份局相同。',
+			'对决模式':'<div style="margin:10px">4v4</div><ul style="margin-top:0"><li>双方各有一名主公和三名忠臣，杀死对方主公获胜<li>'+
+			'8号位游戏开始时额外摸一张牌，7、8号位可在游戏开始时置换一次手牌<li>'+
+			'杀死对方忠臣摸2+x张牌，x为对方（含刚被杀的忠臣）与己方的存活人数之差；主公杀死己方忠臣须弃置所有牌',
 		},
 		help2:{
 			'战棋模式':
@@ -2411,7 +2497,7 @@
 			'开启无尽模式后，任何一方有角色死亡都将选择一名新角色重新加入战场，直到点击左上角的结束游戏按钮手动结束游戏。结束游戏时，杀敌更多的一方获胜<li>'+
 			'开启交替行动时，双方无论存活角色角色多少都将轮流进行行动。在一方所有角色行动完毕进行下一轮行动时，若其人数比另一方少，另一方可指定至多X名角色名摸一张牌，X为人数之差<li>'+
 			'开启战场机关后，每个回合结束时有一定机率出现一个机关，该机关不参与战斗，并有一个影响周围或全体角色的效果。机关在出现后的5〜10个回合内消失<li>'+
-			'开启击退效果后，当一名角色对距离两格以内且在同一直线上的目标造成伤害后，受伤害角色将沿反方向移动一格<li>'+
+			'开启击退效果后，当一名角色对距离两格以内的目标造成伤害后，受伤害角色将沿反方向移动一格<li>'+
 			'战场上可设置出现随机路障，角色无法移动到路障处。当一名角色的周围四格有至少三格为路障或在战场外时，其可以在回合内清除一个相邻路障</ul>'+
 			'<div style="margin:10px">君主模式</div><ul style="margin-top:0"><li>收集武将进行战斗，根据战斗难度及我方出场武将的强度，战斗胜利后将获得数量不等的金钱。没有君主出场时，获得的金钱较多<li>'+
 			'金钱可以用来招募随机武将，招到已有武将，或遣返不需要的武将时可得到招募令<li>'+
@@ -2426,6 +2512,7 @@
 			'炉石模式':
 			'<div style="margin:10px">构筑</div><ul style="margin-top:0"><li>点击右上角的卡组管理构建卡组<li>一套卡组共30张牌，由法术和随从牌构成，每个同名卡牌最多带两张'+
 			'<li>卡组管理器中，随从右上角的x/y表示登场状态为x牌y血'+
+			'<li>游戏开始时，双方摸三张牌并从牌库中获得一张牌，并可选择将手牌置换一次'+
 			'<li>摸牌阶段，主将少摸一张牌，并从卡组中获得一张牌'+
 			'<li>每名角色使用一套卡组，卡组用完后会重新补满'+
 			'<li>卡组与职业绑定，每个职业有一个专属技能，每回合限用一次，消耗两点行动值</ul>'+
@@ -2776,6 +2863,9 @@
 									lib.skill[i].createInfo=skills[i];
 									lib.setTranslate(i);
 									lib.translate[i+'_info']=skills[i].description;
+									if(lib.skill[i].marktext){
+										lib.translate[i+'_bg']=lib.skill[i].marktext;
+									}
 								}
 								if(_status.cardsFinished){
 									game.finishCards();
@@ -3100,9 +3190,9 @@
 			playerproto:{
 				phase:function(){
 					"step 0"
-					if(player.node.judges.childElementCount){
+					// if(player.node.judges.childElementCount){
-						player.popup('判定阶段');
+					// 	player.popup('判定阶段');
-					}
+					// }
 					player.phaseJudge();
 					"step 1"
 					player.phaseDraw();
@@ -3135,6 +3225,7 @@
 						player.$phaseJudge(event.card);
 						event.cancelled=false;
 						event.trigger('phaseJudge');
+						player.popup(event.card.viewAs||event.card.name,'thunder');
 					}
 					else event.finish();
 					"step 1"
@@ -3978,6 +4069,9 @@
 						player.logSkill(event.skill);
 						player.popup(event.card.name);
 					}
+					else if(lib.config.show_card_prompt&&get.type(event.card)!='equip'){
+						player.popup(event.card.name,'metal');
+					}
 					if(event.audio===false){
 						cardaudio=false;
 					}
@@ -4443,6 +4537,9 @@
 							player.checkShow(event.skill);
 						}
 					}
+					else if(lib.config.show_card_prompt){
+						player.popup(card.name,'wood');
+					}
 					if(cardaudio&&event.parent.parent.parent.name=='useCard'){
 						if(lib.config.background_audio){
 							var sex=player.sex=='female'?'female':'male';
@@ -4685,11 +4782,8 @@
 							else if(event.nature=='thunder'){
 								player.$thunder();
 							}
-							player.$damagepop(-num,event.nature);
-						}
-						else{
-							player.popup(-num,event.nature);
 						}
+						player.$damagepop(-num,event.nature);
 					}
 					// if(source){
 					// 	if(player._damagetimeout!=source){
@@ -4732,11 +4826,8 @@
 						player.changeHp(num,false);
 						if(lib.config.animation&&!lib.config.low_performance){
 							player.$recover();
-							player.$damagepop(num,'wood');
-						}
-						else{
-							player.popup('+'+num);
 						}
+						player.$damagepop(num,'wood');
 						game.log(player,'回复了'+get.cnNumber(num)+'点体力')
 					}
 				},
@@ -5593,7 +5684,7 @@
 				syncStorage:function(skill){
 					switch(get.itemtype(this.storage[skill])){
 						case 'cards':game.addVideo('storage',this,[skill,get.cardsInfo(this.storage[skill]),'cards']);break;
-						case 'card':game.addVideo('storage',this,[skill,get.cardInfo(this.storage[skill]),'cards']);break;
+						case 'card':game.addVideo('storage',this,[skill,get.cardInfo(this.storage[skill]),'card']);break;
 						default:game.addVideo('storage',this,[skill,this.storage[skill]]);
 					}
 				},
@@ -6764,6 +6855,11 @@
 				},
 				popup:function(name,className){
 					var name2=get.translation(name);
+					if(true){
+						if(!name2) return;
+						this.$damagepop(name2,className||'water',true);
+						return;
+					}
 					var node=ui.create.div('.popup',this.parentNode);
 					if(!name2){
 						node.remove();
@@ -7009,6 +7105,9 @@
 					this.unmarkSkill(skill);
 					this.skills.remove(skill);
 					this.checkConflict();
+					if(lib.skill[skill]&&lib.skill[skill].onremove){
+						lib.skill[skill].onremove(this);
+					}
 					return skill;
 				},
 				addTempSkill:function(skill,expire){
@@ -7118,6 +7217,7 @@
 						return false;
 					}
 					if(lib.config.mode=='versus'){
+						if(_status.mode=='four'||_status.mode=='jiange') return false;
 						return ui.autoreplace&&ui.autoreplace.classList.contains('on')&&
 							this.side==game.me.side;
 					}
@@ -8037,10 +8137,13 @@
 						node.delete();
 					},1000);
 				},
-				$damagepop:function(num,nature){
+				$damagepop:function(num,nature,font){
 					if(typeof num=='number'||typeof num=='string'){
-						game.addVideo('damagepop',this,[num,nature]);
+						game.addVideo('damagepop',this,[num,nature,font]);
 						var node=ui.create.div('.damage');
+						if(font){
+							node.classList.add('normal-font');
+						}
 						if(num>0){
 							num='+'+num;
 						}
@@ -8548,79 +8651,7 @@
 					if(list.length){
 						list.sort(lib.sort.priority);
 						for(i=0;i<list.length;i++){
-							if(list[i][1].isOut()||list[i][1].isDead()||list[i][1].removed) continue;
+							game.createTrigger(name,list[i][0],list[i][1],event);
-							var next=game.createEvent('trigger',false);
-							next.skill=list[i][0];
-							next.player=list[i][1];
-							next.triggername=name;
-							next._trigger=event;
-							next.content=function(){
-								"step 0"
-								var info=get.info(event.skill);
-								if(info.filter&&!info.filter(trigger,player,event.triggername)){
-									event.finish();
-								}
-								else if(event._trigger.notrigger.contains(player)&&!lib.skill.global.contains(event.skill)){
-									event.finish();
-								}
-								else{
-									var hidden=player.hiddenSkills.slice(0);
-									game.expandSkills(hidden);
-									if(hidden.contains(event.skill)&&!get.info(event.skill).direct){
-										event.trigger('triggerHidden');
-									}
-								}
-								"step 1"
-								if(event.cancelled){
-									event.finish();
-								}
-								else{
-									event.trigger('triggerBefore');
-								}
-								"step 2"
-								if(event.cancelled){
-									event.finish();
-									return;
-								}
-								if(!event.revealed&&!get.info(event.skill).forced){
-									if(get.info(event.skill).direct&&player.isUnderControl()){
-										game.modeSwapPlayer(player);
-										event._result={bool:true};
-									}
-									else if(get.info(event.skill).frequent&&!lib.config.autoskilllist.contains(event.skill)){
-										event._result={bool:true};
-									}
-									else if(get.info(event.skill).direct&&player==game.me&&!_status.auto){
-										event._result={bool:true};
-									}
-									else{
-										var str;
-										var check=get.info(event.skill).check;
-										if(get.info(event.skill).prompt) str=get.info(event.skill).prompt;
-										else str='是否发动【'+get.translation(event.skill)+'】？';
-										if(typeof str=='function'){str=str(trigger,player)}
-										player.chooseBool(str).ai=function(){
-											return !check||check(trigger,player);
-										};
-									}
-								}
-								"step 3"
-								if(result&&result.bool==false) return;
-								var info=get.info(event.skill);
-								var next=game.createEvent(event.skill);
-								next.player=player;
-								next._trigger=trigger;
-								next.content=info.content;
-								if(info.popup!=false&&!info.direct){
-									if(info.popup){
-										player.popup(info.popup);
-										game.log(player,'发动了','【'+get.translation(event.skill)+'】');
-									}
-									else{
-										player.logSkill(event.skill);
-									}
-								}
-							}
 						}
 					}
 				},
@@ -9041,7 +9072,7 @@
 				popup:false,
 				content:function(){
 					if(!player.noPhaseDelay){
-						player.popup('_phasebegin');
+						player.popup('回合开始');
 					}
 					if(lib.config.glow_phase){
 						if(_status.currentPhase){
@@ -9650,6 +9681,9 @@
 		videoContent:{
 			init:function(players){
 				if(lib.config.mode=='chess') return;
+				if(lib.config.mode=='versus'){
+					players.bool=players.pop();
+				}
 				ui.arena.dataset.number=players.length;
 				ui.arena.classList.add('video');
 				game.players.length=0;
@@ -10197,7 +10231,7 @@
 			},
 			damagepop:function(player,content){
 				if(player&&content){
-					player.$damagepop(content[0],content[1]);
+					player.$damagepop(content[0],content[1],content[2]);
 				}
 				else{
 					console.log(player);
@@ -11078,7 +11112,83 @@
 				game.draw(drawfunc);
 			}
 		},
-		createEvent:function(name,trigger){
+		createTrigger:function(name,skill,player,event){
+			if(player.isOut()||player.isDead()||player.removed) return;
+			var next=game.createEvent('trigger',false,event);
+			next.skill=skill;
+			next.player=player;
+			next.triggername=name;
+			next._trigger=event;
+			next.content=function(){
+				"step 0"
+				var info=get.info(event.skill);
+				if(info.filter&&!info.filter(trigger,player,event.triggername)){
+					event.finish();
+				}
+				else if(event._trigger.notrigger.contains(player)&&!lib.skill.global.contains(event.skill)){
+					event.finish();
+				}
+				else{
+					var hidden=player.hiddenSkills.slice(0);
+					game.expandSkills(hidden);
+					if(hidden.contains(event.skill)&&!get.info(event.skill).direct){
+						event.trigger('triggerHidden');
+					}
+				}
+				"step 1"
+				if(event.cancelled){
+					event.finish();
+				}
+				else{
+					event.trigger('triggerBefore');
+				}
+				"step 2"
+				if(event.cancelled){
+					event.finish();
+					return;
+				}
+				if(!event.revealed&&!get.info(event.skill).forced){
+					if(get.info(event.skill).direct&&player.isUnderControl()){
+						game.modeSwapPlayer(player);
+						event._result={bool:true};
+					}
+					else if(get.info(event.skill).frequent&&!lib.config.autoskilllist.contains(event.skill)){
+						event._result={bool:true};
+					}
+					else if(get.info(event.skill).direct&&player==game.me&&!_status.auto){
+						event._result={bool:true};
+					}
+					else{
+						var str;
+						var check=get.info(event.skill).check;
+						if(get.info(event.skill).prompt) str=get.info(event.skill).prompt;
+						else str='是否发动【'+get.translation(event.skill)+'】？';
+						if(typeof str=='function'){str=str(trigger,player)}
+						player.chooseBool(str).ai=function(){
+							return !check||check(trigger,player);
+						};
+					}
+				}
+				"step 3"
+				if(result&&result.bool==false) return;
+				var info=get.info(event.skill);
+				var next=game.createEvent(event.skill);
+				next.player=player;
+				next._trigger=trigger;
+				next.triggername=event.triggername;
+				next.content=info.content;
+				if(info.popup!=false&&!info.direct){
+					if(info.popup){
+						player.popup(info.popup);
+						game.log(player,'发动了','【'+get.translation(event.skill)+'】');
+					}
+					else{
+						player.logSkill(event.skill);
+					}
+				}
+			}
+		},
+		createEvent:function(name,trigger,triggerevent){
 			var next={
 				name:name,
 				step:0,
@@ -11096,7 +11206,7 @@
 			for(var i in lib.element.event){
 				next[i]=lib.element.event[i];
 			}
-			_status.event.next.push(next);
+			(triggerevent||_status.event).next.push(next);
 			return next;
 		},
 		createCard:function(name,suit,number,nature){
@@ -11186,7 +11296,9 @@
 							added=added*(game.players.length+game.dead.length);
 							break;
 						case 'versus':
-							added=5*(game.players.length+_status.friend.length);
+							if(_status.friend){
+								added=5*(game.players.length+_status.friend.length);
+							}
 							break;
 						default:
 							added=10;
@@ -11566,7 +11678,7 @@
 					event._triggered++;
 				}
 				else{
-					if(player&&player.classList.contains('dead')&&event.name!='phaseLoop'){
+					if(player&&player.classList.contains('dead')&&!event.forceDie&&event.name!='phaseLoop'){
 						while(_status.dieClose.length){
 							_status.dieClose.shift().close();
 						}
@@ -12164,8 +12276,12 @@
 					player=player.next;
 				}
 				while(player!=end);
+				event.changeCard=get.config('change_card');
+				if(lib.config.mode!='identity'&&lib.config.mode!='guozhan'){
+					event.changeCard='disabled';
+				}
 				"step 1"
-				if(get.config('change_card')){
+				if(event.changeCard!='disabled'){
 					event.dialog=ui.create.dialog('是否使用手气卡？');
 					ui.create.confirm('oc');
 					event.custom.replace.confirm=function(bool){
@@ -12177,24 +12293,34 @@
 					event.finish();
 				}
 				"step 2"
+				if(event.changeCard=='once'){
+					event.changeCard='disabled';
+				}
+				else if(event.changeCard=='twice'){
+					event.changeCard='once';
+				}
+				else if(event.changeCard=='disabled'){
+					event.bool=false;
+					return;
+				}
 				game.pause();
 				"step 3"
 				if(event.bool){
 					if(game.changeCoin){
 						game.changeCoin(-3);
 					}
-					game.me.lose(game.me.get('h'))._triggered=null;
+					var hs=game.me.get('h');
+					for(var i=0;i<hs.length;i++){
+						ui.discardPile.appendChild(hs[i]);
+					}
+					game.me.directgain(get.cards(hs.length));
+					event.goto(2);
 				}
 				else{
 					event.dialog.close();
 					ui.confirm.close();
 					event.finish();
 				}
-				"step 4"
-				game.delay();
-				game.me.gain(get.cards(4))._triggered=null;
-				"step 5"
-				event.goto(2);
 			}
 		},
 		asyncDraw:function(players,num){
@@ -12326,6 +12452,9 @@
 						if(lib.skill[i].subSkill[j].description){
 							lib.translate[i+'_'+j+'_info']=lib.skill[i].subSkill[j].description;
 						}
+						if(lib.skill[i].subSkill[j].marktext){
+							lib.translate[i+'_'+j+'_bg']=lib.skill[i].subSkill[j].marktext;
+						}
 					}
 				}
 				if(i[0]=='_'){
@@ -17496,7 +17625,6 @@
 				if(this.classList.contains('selectable')&&
 					!this.classList.contains('selected')&&
 					!this.classList.contains('noclick')){
-						game.print(1)
 					this._waitingfordrag={clientX:e.touches[0].clientX,clientY:e.touches[0].clientY};
 				}
 			},
@@ -19269,7 +19397,11 @@
 			return info;
 		},
 		infoCard:function(info){
-			return ui.create.card().init(info);
+			var card=ui.create.card();
+			if(info[0]){
+				card.init(info);
+			}
+			return card;
 		},
 		infoCards:function(info){
 			var cards=[];

game/package.js

@@ -1,16 +1,13 @@
 character.pack={
     standard:'标准',
-    wind:'风包',
+    shenhua:'神话再临',
-    fire:'火包',
-    woods:'林包',
-    mountain:'山包',
     refresh:'界限突破',
     extra:'神将',
     sp:'SP',
     guozhan:'国战',
     yijiang:'一将成名',
-    jiange:'守卫剑阁',
+    // jiange:'守卫剑阁',
-    zhuogui:'捉鬼驱邪',
+    // zhuogui:'捉鬼驱邪',
     diy:'DIY',
     yxs:'英雄杀',
     hearth:'炉石传说',

layout/default/layout.css

@@ -623,6 +623,15 @@ margin-bottom: 5px;
 	transform:scale(2);
 	font-size: 120px;
 }
+.damage.normal-font{
+	font-family: xinwei;
+    font-size: 30px;
+    top: calc(50% - 15px);
+}
+.player.minskin>.damage.normal-font{
+	font-size: 26px;
+    top: calc(50% - 13px);
+}
 .player[data-position='0']>.damage.dieidentity,
 .player:not(.dead)>.damage.dieidentity{
 	opacity: 0 !important

layout/mobile/layout.css

@@ -64,9 +64,10 @@
     top: calc(100% - 150px);
     background: none !important;
     border:none !important;
+    border-radius: 0 !important;
     pointer-events: none;
 }
-#arena:not(.chess) .player[data-position='0']:not(.selected):not(.selectable):not(.glow){
+#arena:not(.chess) .player[data-position='0']:not(.selected):not(.selectedx):not(.selectable):not(.glow){
     box-shadow: none !important;
 }
 #arena:not(.chess) .player[data-position='0']:not(.minskin)>.avatar,

mode/chess.js

@@ -396,12 +396,19 @@ mode.chess={
 					}
 				}
 				if(_status.mode=='combat'&&!_status.vsboss){
+					if(game.players.length==1&&get.config('additional_player')&&
+					_status.additionallist.length&&source==game.players[0]){
+						source.draw(get.config('reward'));
+					}
 					if(player.side==game.me.side){
 						if(get.config('additional_player')&&_status.additionallist.length){
 							game.replaceChessPlayer();
 							return;
 						}
 						else if(_status.replacelist.length){
+							if(game.players.length==1&&source==game.players[0]){
+								source.draw(get.config('reward'));
+							}
 							game.replaceChessPlayer(_status.replacelist.randomRemove());
 							return;
 						}
@@ -419,6 +426,9 @@ mode.chess={
 							return;
 						}
 						else if(_status.enemyreplacelist.length){
+							if(game.players.length==1&&source==game.players[0]){
+								source.draw(get.config('reward'));
+							}
 							game.replaceChessPlayer(_status.enemyreplacelist.randomRemove(),true);
 							return;
 						}
@@ -673,6 +683,7 @@ mode.chess={
 						event.filterButton=function(){return true;};
 						event.player=game.me;
 						event.forced=true;
+						event.forceDie=true;
 						event.custom.replace.confirm=function(){
 							event.playername=ui.selected.buttons[0].link;
 							event.dialog.close();
@@ -693,6 +704,7 @@ mode.chess={
 					event.filterButton=function(){return true;};
 					event.player=game.me;
 					event.forced=true;
+					event.forceDie=true;
 					event.custom.replace.confirm=function(){
 						event.playername=ui.selected.buttons[0].link;
 						event.dialog.close();
@@ -706,12 +718,18 @@ mode.chess={
 				else{
 					game.delay();
 				}
+				if(game.me.isDead()){
+					event.swapNow=true;
+				}
 				'step 1'
 				var player=game.addChessPlayer(event.playername,event.enemy);
 				game.log(player,'加入游戏');
 				player.chessFocus();
 				player.playerfocus(1000);
 				game.delay(2);
+				if(event.swapNow&&player.side==game.me.side){
+					game.modeSwapPlayer(player);
+				}
 			},
 			chooseToMove:function(){
 				"step 0"
@@ -1864,6 +1882,7 @@ mode.chess={
 				}
 				else{
 					switch(num){
+						case 1:ui.chessheight=4;break;
 						case 2:ui.chessheight=5;break;
 						case 3:ui.chessheight=5;break;
 						case 4:ui.chessheight=6;break;
@@ -1871,9 +1890,11 @@ mode.chess={
 						case 6:ui.chessheight=7;break;
 						case 7:ui.chessheight=7;break;
 						case 8:ui.chessheight=8;break;
+						default:ui.chessheight=8;
 					}
 					ui.chesswidth=Math.round(ui.chessheight*1.5);
 				}
+				if(num==1) ui.chesswidth++;
 				ui.chess.style.height=148*ui.chessheight+'px';
 				ui.chess.style.width=148*ui.chesswidth+'px';
 				if(!lib.config.touchscreen){
@@ -3783,8 +3804,16 @@ mode.chess={
 				var i;
 				var list=[];
 				var bosslist=[];
+				var jiangelist=[];
 				event.list=list;
 				for(i in lib.character){
+					if(lib.character[i][4].contains('chessboss')){
+						bosslist.push(i);continue;
+					}
+					else if(lib.character[i][4].contains('jiangeboss')){
+						// if(get.config('chess_jiange')) jiangelist.push(i);
+						continue;
+					}
 					if(i.indexOf('treasure_')==0) continue;
 					if(i.indexOf('chess_mech_')==0) continue;
 					if(lib.character[i][4]&&lib.character[i][4].contains('forbidai')) continue;
@@ -3794,12 +3823,9 @@ mode.chess={
 					if(lib.config.banned.contains(i)) continue;
 					if(lib.config.forbidchess.contains(i)) continue;
 					if(get.config('ban_weak')&&lib.config.forbidsingle.contains(i)) continue;
-					if(lib.character[i][4].contains('boss')){
+					if(get.config('ban_strong')&&(lib.rank.s.contains(i)||lib.rank.ap.contains(i))) continue;
-						bosslist.push(i);
+
-					}
+					list.push(i);
-					else{
-						list.push(i);
-					}
 				}
 				list.randomSort();
 				var bosses=ui.create.div('.buttons');
@@ -3810,6 +3836,10 @@ mode.chess={
 					_status.event.dialog.content.childNodes[1].innerHTML=
 					ui.selected.buttons.length+'/'+_status.event.selectButton();
 				};
+				var jiange=ui.create.div('.buttons');
+				event.jiange=jiange;
+				var jiangebuttons=ui.create.buttons(jiangelist,'character',jiange);
+
 				var clickedBoss=false;
 				var clickBoss=function(){
 					clickedBoss=true;
@@ -3848,10 +3878,28 @@ mode.chess={
 					}
 					addToButton();
 				};
+
+				var clickedJiange=false;
+				var clickJiange=function(){
+					clickedJiange=true;
+					if(this.classList.contains('glow2')){
+						this.classList.remove('glow2');
+					}
+					else{
+						this.classList.add('glow2');
+					}
+					addToButton();
+				};
+
+
 				for(var i=0;i<bossbuttons.length;i++){
 					bossbuttons[i].classList.add('noclick');
 					bossbuttons[i].listen(clickBoss);
 				}
+				for(var i=0;i<jiangebuttons.length;i++){
+					jiangebuttons[i].classList.add('noclick');
+					jiangebuttons[i].listen(clickJiange);
+				}
 
 				if(get.config('reward')==undefined) game.saveConfig('reward',1,true);
 				if(get.config('punish')==undefined) game.saveConfig('punish','无',true);
@@ -3870,6 +3918,10 @@ mode.chess={
 					dialog.add('挑战魔王');
 					dialog.add(bosses);
 				}
+				if(jiangebuttons.length){
+					dialog.add('守卫剑阁');
+					dialog.add(jiange);
+				}
 				event.addConfig=function(dialog){
 					dialog.add('选项');
 					dialog.choice={};
@@ -3891,7 +3943,7 @@ mode.chess={
 					dialog.choice.reward=dialog.add(ui.create.switcher('reward',[0,1,2,3,4],get.config('reward'))).querySelector('.toggle');
 					dialog.choice.punish=dialog.add(ui.create.switcher('punish',['弃牌','无','摸牌'],get.config('punish'))).querySelector('.toggle');
 					dialog.choice.seat_order=dialog.add(ui.create.switcher('seat_order',['交替','随机'],get.config('seat_order'))).querySelector('.toggle');
-					dialog.choice.battle_number=dialog.add(ui.create.switcher('battle_number',[2,3,4,6,8],get.config('battle_number'))).querySelector('.toggle');
+					dialog.choice.battle_number=dialog.add(ui.create.switcher('battle_number',[1,2,3,4,6,8],get.config('battle_number'))).querySelector('.toggle');
 					dialog.choice.replace_number=dialog.add(ui.create.switcher('replace_number',[0,1,2,3,5,7,9,17],get.config('replace_number'))).querySelector('.toggle');
 					dialog.choice.choice_number=dialog.add(ui.create.switcher('choice_number',[3,6,9],get.config('choice_number'))).querySelector('.toggle');
 					if(get.config('additional_player')){
@@ -3909,6 +3961,9 @@ mode.chess={
 				for(var i=0;i<bosses.childNodes.length;i++){
 					bosses.childNodes[i].classList.add('squarebutton');
 				}
+				for(var i=0;i<jiange.childNodes.length;i++){
+					jiange.childNodes[i].classList.add('squarebutton');
+				}
 				ui.control.style.transition='all 0s';
 				if(lib.config.layout=='mobile'||lib.config.layout=='default'){
 					ui.control.style.top='calc(100% - 70px)';
@@ -3948,6 +4003,15 @@ mode.chess={
 							delete event.asboss;
 						}
 					}
+					if(clickedJiange){
+						clickedJiange=false;
+					}
+					else{
+						for(var i=0;i<jiange.childElementCount;i++){
+							jiange.childNodes[i].classList.remove('forbidden');
+							jiange.childNodes[i].classList.remove('glow2');
+						}
+					}
 					var dialog=_status.event.dialog;
 					if(dialog.choice){
 						for(var i in dialog.choice){
@@ -4005,6 +4069,10 @@ mode.chess={
 						dialog.add('挑战魔王');
 						dialog.add(bosses);
 					}
+					if(jiangebuttons.length){
+						dialog.add('守卫剑阁');
+						dialog.add(jiange);
+					}
 					event.addConfig(dialog);
 					dialog.open();
 					game.uncheck();
@@ -4098,6 +4166,7 @@ mode.chess={
 					event.list.remove(result.links[i]);
 				}
 				var glows=event.bosses.querySelectorAll('.glow');
+				var glows2=event.jiange.querySelectorAll('.glow2');
 				if(glows.length){
 					_status.vsboss=true;
 					_status.enemylist=[];
@@ -4113,6 +4182,13 @@ mode.chess={
 						}
 					}
 				}
+				else if(glows2.length){
+					_status.vsboss=true;
+					_status.enemylist=[];
+					for(var i=0;i<glows2.length;i++){
+						_status.enemylist.push(glows2[i].link);
+					}
+				}
 				else{
 					event.list.randomSort();
 					_status.enemylist=event.list.splice(0,_status.mylist.length);
@@ -4333,7 +4409,7 @@ mode.chess={
 				var xy2=player.getXY();
 				var dx=xy2[0]-xy1[0];
 				var dy=xy2[1]-xy1[1];
-				if(dx*dy!=0) return false;
+				// if(dx*dy!=0) return false;
 				if(dx==0&&Math.abs(dy)==2){
 					dy/=2;
 				}
@@ -5124,10 +5200,10 @@ mode.chess={
 				}
 			},
 		},
-		boss_baolin:{
+		boss_stonebaolin:{
 			inherit:'juece',
 		},
-		boss_qiangzheng:{
+		boss_stoneqiangzheng:{
 			trigger:{player:'phaseEnd'},
             forced:true,
 			unique:true,
@@ -5820,9 +5896,9 @@ mode.chess={
 		guanchuan:'贯穿射击',
 		guanchuan_info:'当你使用杀指定惟一的目标后，可将攻击射线内的其他角色也加入目标',
 
-		boss_qiangzheng:'强征',
+		boss_stoneqiangzheng:'强征',
-		boss_qiangzheng_info:'锁定技，回合结束阶段，你获得每个其他角色的一张手牌',
+		boss_stoneqiangzheng_info:'锁定技，回合结束阶段，你获得每个其他角色的一张手牌',
-		boss_baolin:'暴凌',
+		boss_stonebaolin:'暴凌',
 		boss_moyan:'魔焰',
 		boss_moyan_info:'锁定技，回合结束阶段，你对场上所有角色造成一点火焰伤害',
 
@@ -6164,11 +6240,11 @@ mode.chess={
 			// chess_zhangjiao:['male','qun',3,['']],
 			// chess_menghuo:['male','qun',3,['']],
 			//
-			chess_jinchidiao:['male','qun',15,['boss_fengxing','boss_chiyu'],['boss']],
+			chess_jinchidiao:['male','qun',15,['boss_fengxing','boss_chiyu'],['boss','chessboss']],
-			chess_beimingjukun:['male','qun',25,['boss_wuying','cangming'],['boss']],
+			chess_beimingjukun:['male','qun',25,['boss_wuying','cangming'],['boss','chessboss']],
-			chess_wuzhaojinlong:['male','qun',30,['boss_tenglong','boss_wushang'],['boss']],
+			chess_wuzhaojinlong:['male','qun',30,['boss_tenglong','boss_wushang'],['boss','chessboss']],
-			chess_dongzhuo:['male','qun',20,['jiuchi','boss_qiangzheng','boss_baolin'],['boss']],
+			chess_dongzhuo:['male','qun',20,['jiuchi','boss_stoneqiangzheng','boss_stonebaolin'],['boss','chessboss']],
-			chess_xingtian:['male','qun',99,['boss_moyan','wushuang'],['boss']],
+			chess_xingtian:['male','qun',99,['boss_moyan','wushuang'],['boss','chessboss']],
 		}
 	},
 	cardPack:{

mode/stone.js

@@ -363,7 +363,12 @@ mode.stone={
 					}
 				}
 				if(source&&source.side!=this.side&&!source.isMin()){
-					source.draw(2,{drawDeck:1});
+					if(_status.mode=='deck'){
+						source.draw(2,{drawDeck:1});
+					}
+					else{
+						source.draw(2);
+					}
 					if(source.getActCount()>0){
 						source.actused--;
 					}
@@ -1176,6 +1181,23 @@ mode.stone={
 				else{
 					game.gameDraw(game.me);
 				}
+				"step 4"
+				game.me.chooseBool('是否置换手牌？');
+				"step 5"
+				if(result.bool){
+					var hs=game.me.get('h');
+					for(var i=0;i<hs.length;i++){
+						ui.discardPile.appendChild(hs[i]);
+					}
+					if(_status.mode=='deck'){
+						game.me.drawDeck(1,false);
+						game.me.directgain(get.cards(3));
+					}
+					else{
+						game.me.directgain(get.cards(4));
+					}
+				}
+				"step 6"
 				if(game.me.side){
 					game.stoneLoop(game.me);
 				}

mode/versus.js

@@ -43,6 +43,7 @@ mode.versus={
 					_status.waitingForCharacters=true;
 					game.pause();
 				}
+				_status.mode=get.config('versus_mode');
 				"step 1"
 				var playback=localStorage.getItem(lib.configprefix+'playback');
 				if(playback){
@@ -64,105 +65,529 @@ mode.versus={
 					event.finish();
 					return;
 				}
-				if(lib.storage.choice==undefined) game.save('choice',20);
+				if(_status.mode=='jiange'||_status.mode=='four'){
-				if(lib.storage.zhu==undefined) game.save('zhu',true);
+					game.prepareArena(8);
-				if(lib.storage.noreplace_end==undefined) game.save('noreplace_end',true);
+					// game.pause();
-				if(get.config('first_less')==undefined) game.saveConfig('first_less',true,true);
-				if(lib.storage.autoreplaceinnerhtml==undefined) game.save('autoreplaceinnerhtml',true);
-				// if(lib.storage.only_zhu==undefined) game.save('only_zhu',true);
-				if(lib.storage.single_control==undefined) game.save('single_control',true);
-				if(lib.storage.number==undefined) game.save('number',3);
-				if(lib.storage.versus_reward==undefined) game.save('versus_reward',3);
-				if(lib.storage.versus_punish==undefined) game.save('versus_punish','弃牌');
-				if(lib.storage.replace_number==undefined) game.save('replace_number',3);
-				// if(lib.storage.control_all==undefined) game.save('control_all',true);
-
-				switch(lib.storage.seat_order){
-					case '交叉':lib.storage.cross_seat=true;lib.storage.random_seat=false;break;
-					case '随机':lib.storage.cross_seat=false;lib.storage.random_seat=true;break;
-					default:lib.storage.cross_seat=false;lib.storage.random_seat=false;
 				}
-				game.save('only_zhu',true);
+				else{
-				game.save('control_all',true);
+					if(lib.storage.choice==undefined) game.save('choice',20);
+					if(lib.storage.zhu==undefined) game.save('zhu',true);
+					if(lib.storage.noreplace_end==undefined) game.save('noreplace_end',true);
+					if(get.config('first_less')==undefined) game.saveConfig('first_less',true,true);
+					if(lib.storage.autoreplaceinnerhtml==undefined) game.save('autoreplaceinnerhtml',true);
+					if(lib.storage.single_control==undefined) game.save('single_control',true);
+					if(lib.storage.number==undefined) game.save('number',3);
+					if(lib.storage.versus_reward==undefined) game.save('versus_reward',3);
+					if(lib.storage.versus_punish==undefined) game.save('versus_punish','弃牌');
+					if(lib.storage.replace_number==undefined) game.save('replace_number',3);
 
-				ui.create.cards();
+					switch(lib.storage.seat_order){
-				game.finishCards();
+						case '交叉':lib.storage.cross_seat=true;lib.storage.random_seat=false;break;
-				// ui.auto.hide();
+						case '随机':lib.storage.cross_seat=false;lib.storage.random_seat=true;break;
-				ui.wuxie.hide();
+						default:lib.storage.cross_seat=false;lib.storage.random_seat=false;
+					}
+					game.save('only_zhu',true);
+					game.save('control_all',true);
+					ui.wuxie.hide();
+					ui.create.cards();
+					game.finishCards();
+				}
 				game.delay();
 				"step 2"
-				game.chooseCharacter();
+				if(_status.mode=='four'){
-				"step 3"
+					var list=['zhu','zhong','zhong','zhong','ezhu','ezhong','ezhong','ezhong'];
-				event.trigger('gameStart');
+					list.randomSort();
-				var firstAct;
+					var side=Math.random()<0.5;
-				if(lib.storage.zhu){
+					for(var i=0;i<8;i++){
-					firstAct=(_status.currentSide==game.me.side)?game.friendZhu:game.enemyZhu;
+						if(list[i][0]=='e'){
+							game.players[i].side=side;
+							game.players[i].identity=list[i].slice(1);
+						}
+						else{
+							game.players[i].side=!side;
+							game.players[i].identity=list[i];
+						}
+						if(game.players[i].identity=='zhu'){
+							game[game.players[i].side+'Zhu']=game.players[i];
+							game.players[i].isZhu=true;
+						}
+						game.players[i].setIdentity(game.players[i].identity);
+						game.players[i].node.identity.dataset.color=get.translation(game.players[i].side+'Color');
+					}
+					game.chooseCharacterFour();
 				}
-				else{
+				else if(_status.mode=='jiange'){
-					if(!lib.storage.cross_seat&&!lib.storage.random_seat&&lib.storage.number>1){
+					var list=['shumech','shu','shuboss','shu','wei','weiboss','wei','weimech'];
-						for(var i=0;i<game.players.length-1;i++){
+					var pos=Math.floor(Math.random()*8);
-							if(game.players[i].side!=game.players[i+1].side){
+					for(var i=0;i<8;i++){
-								var actcount;
+						var j=pos+i;
-								if(Math.random()<0.5){
+						if(j>=8){
-									actcount=i;
+							j-=8;
-								}
+						}
-								else{
+						if(list[i][0]=='w'){
-									if(i>=lib.storage.number){
+							game.players[j].side=true;
-										actcount=i-lib.storage.number;
+							game.players[j].setIdentity('wei');
-									}
+							game.players[j].identity='wei';
-									else{
+						}
-										actcount=i+lib.storage.number;
+						else{
-									}
+							game.players[j].side=false;
-								}
+							game.players[j].setIdentity('shu');
-								if(actcount>0){
+							game.players[j].identity='shu';
-									actcount--;
+						}
-								}
+						if(list[i].indexOf('mech')!=-1){
-								else{
+							game.players[j].type='mech';
-									actcount=game.players.length-1;
+						}
-								}
+						else if(list[i].indexOf('boss')!=-1){
-								firstAct=game.players[actcount];
+							game.players[j].type='boss';
-								break;
+						}
-							}
+						else{
+							game.players[j].type='human';
 						}
 					}
-					else{
+					game.chooseCharacterJiange();
-						firstAct=game.players[Math.floor(Math.random()*game.players.length)];
-					}
-				}
-				game.gameDraw(firstAct,4);
-				_status.first_less=true;
-				_status.round=0;
-				if(lib.storage.single_control){
-					lib.skill.global.push('versus_swap');
-					ui.autoreplace=ui.create.div('.caption.normal');
-					ui.autoreplace.innerHTML='<div class="underline">自动换人</div>';
-					ui.autoreplace.style.textAlign='center';
-					if(lib.storage.autoreplaceinnerhtml){
-						ui.autoreplace.classList.add('on')
-					}
-					ui.autoreplace.listen(game.switchAutoreplace);
-
-					// ui.versusreplace=ui.create.system('换人',null,true);
-					// lib.setPopped(ui.versusreplace,game.versusHoverReplace);
-					if(game.players.length>2){
-						ui.versushs=ui.create.system('手牌',null,true);
-						lib.setPopped(ui.versushs,game.versusHoverHandcards,220);
-					}
-				}
-				_status.enemyCount=ui.create.system('杀敌: '+get.cnNumber(0,true),null,true);
-				_status.friendCount=ui.create.system('阵亡: '+get.cnNumber(0,true),null,true);
-				// _status.friendCount=ui.create.system('友方',null,true);
-				// _status.enemyCount=ui.create.system('敌方',null,true);
-
-				lib.setPopped(_status.friendCount,game.versusHoverFriend);
-				lib.setPopped(_status.enemyCount,game.versusHoverEnemy);
-
-				if(lib.storage.zhu){
-					_status.currentSide=true;
-					game.versusPhaseLoop(firstAct);
 				}
 				else{
-					game.versusPhaseLoop(firstAct);
+					game.chooseCharacter();
+				}
+				"step 3"
+				var players=get.players(lib.sort.position);
+				var info=[];
+				for(var i=0;i<players.length;i++){
+					info.push({
+						name:players[i].name,
+						name2:players[i].name2,
+						identity:players[i].node.identity.firstChild.innerHTML,
+						color:players[i].node.identity.dataset.color
+					});
+				}
+				_status.videoInited=true;
+				if(_status.mode=='four'||_status.mode=='jiange'){
+					info.push(false);
+				}
+				else{
+					info.push(lib.storage.single_control&&lib.storage.control_all&&game.players.length>=4);
+				}
+				game.addVideo('init',null,info);
+				event.trigger('gameStart');
+				if(_status.mode=='four'){
+					game.gameDraw(_status.firstAct,function(player){
+						if(player==_status.firstAct.previousSeat){
+							return 5;
+						}
+						return 4;
+					});
+					if(game.me==_status.firstAct.previous||game.me==_status.firstAct.previous.previous){
+						game.me.chooseBool('是否置换手牌？');
+						event.replaceCard=true;
+					}
+				}
+				else if(_status.mode=='jiange'){
+					var firstAct;
+					for(var i=0;i<game.players.length;i++){
+						if(game.players[i].type=='mech'&&game.players[i].group=='wei'){
+							firstAct=game.players[i];break;
+						}
+					}
+					_status.actlist=[
+						firstAct,
+						firstAct.next,
+						firstAct.previous,
+						firstAct.next.next,
+						firstAct.previous.previous,
+						firstAct.next.next.next,
+						firstAct.previous.previous.previous,
+						firstAct.next.next.next.next
+					];
+					game.gameDraw(firstAct);
+					game.phaseLoopJiange();
+				}
+				else{
+					var firstAct;
+					if(lib.storage.zhu){
+						firstAct=(_status.currentSide==game.me.side)?game.friendZhu:game.enemyZhu;
+					}
+					else{
+						if(!lib.storage.cross_seat&&!lib.storage.random_seat&&lib.storage.number>1){
+							for(var i=0;i<game.players.length-1;i++){
+								if(game.players[i].side!=game.players[i+1].side){
+									var actcount;
+									if(Math.random()<0.5){
+										actcount=i;
+									}
+									else{
+										if(i>=lib.storage.number){
+											actcount=i-lib.storage.number;
+										}
+										else{
+											actcount=i+lib.storage.number;
+										}
+									}
+									if(actcount>0){
+										actcount--;
+									}
+									else{
+										actcount=game.players.length-1;
+									}
+									firstAct=game.players[actcount];
+									break;
+								}
+							}
+						}
+						else{
+							firstAct=game.players[Math.floor(Math.random()*game.players.length)];
+						}
+					}
+					game.gameDraw(firstAct,4);
+					_status.first_less=true;
+					_status.round=0;
+					if(lib.storage.single_control){
+						lib.skill.global.push('versus_swap');
+						ui.autoreplace=ui.create.div('.caption.normal');
+						ui.autoreplace.innerHTML='<div class="underline">自动换人</div>';
+						ui.autoreplace.style.textAlign='center';
+						if(lib.storage.autoreplaceinnerhtml){
+							ui.autoreplace.classList.add('on')
+						}
+						ui.autoreplace.listen(game.switchAutoreplace);
+
+						// ui.versusreplace=ui.create.system('换人',null,true);
+						// lib.setPopped(ui.versusreplace,game.versusHoverReplace);
+						if(game.players.length>2){
+							ui.versushs=ui.create.system('手牌',null,true);
+							lib.setPopped(ui.versushs,game.versusHoverHandcards,220);
+						}
+					}
+					_status.enemyCount=ui.create.system('杀敌: '+get.cnNumber(0,true),null,true);
+					_status.friendCount=ui.create.system('阵亡: '+get.cnNumber(0,true),null,true);
+					// _status.friendCount=ui.create.system('友方',null,true);
+					// _status.enemyCount=ui.create.system('敌方',null,true);
+
+					lib.setPopped(_status.friendCount,game.versusHoverFriend);
+					lib.setPopped(_status.enemyCount,game.versusHoverEnemy);
+
+					if(lib.storage.zhu){
+						_status.currentSide=true;
+						game.versusPhaseLoop(firstAct);
+					}
+					else{
+						game.versusPhaseLoop(firstAct);
+					}
+				}
+				if(_status.mode!='four'){
+					event.finish();
+				}
+				"step 4"
+				if(event.replaceCard&&result.bool){
+					var hs=game.me.get('h');
+					for(var i=0;i<hs.length;i++){
+						ui.discardPile.appendChild(hs[i]);
+					}
+					game.me.directgain(get.cards(hs.length));
+				}
+				game.phaseLoop(_status.firstAct);
+			}
+		},
+		chooseCharacterJiange:function(){
+			var next=game.createEvent('chooseCharacter',false);
+			next.showConfig=true;
+			next.content=function(){
+				'step 0'
+				var list={
+					weilist:[],shulist:[],
+					weimech:[],shumech:[],
+					weiboss:[],shuboss:[],
+				}
+				event.list=list;
+				for(var i in lib.character){
+					if(lib.character[i][4]){
+						if(lib.character[i][4].contains('jiangeboss')){
+							list[lib.character[i][1]+'boss'].push(i);continue;
+						}
+						else if(lib.character[i][4].contains('jiangemech')){
+							list[lib.character[i][1]+'mech'].push(i);continue;
+						}
+					}
+					if(lib.character[i][4]&&lib.character[i][4].contains('forbidai')) continue;
+					if(lib.config.forbidai.contains(i)) continue;
+					if(lib.config.forbidall.contains(i)) continue;
+					if(lib.config.banned.contains(i)) continue;
+					if(!get.config('double_character')&&get.config('ban_weak')&&
+					(lib.config.forbidsingle.contains(i)||lib.rank.c.contains(i)||lib.rank.d.contains(i))) continue;
+					if(get.config('ban_strong')&&(lib.rank.s.contains(i)||lib.rank.ap.contains(i))) continue;
+					if(get.config('double_character')&&lib.config.forbiddouble.contains(i)) continue;
+					if(lib.character[i][1]=='wei'){
+						list.weilist.push(i);
+					}
+					else if(lib.character[i][1]=='shu'){
+						list.shulist.push(i);
+					}
+				}
+				if(!list.weiboss.length){
+					alert('剑阁模式不可隐藏boss武将包，请在选项－其它中选择“重置隐藏扩展包”');
+					event.finish();
+					_status.over=true;
+					return;
+				}
+				var dialog;
+				switch(game.me.type){
+					case 'human':
+						for(var i=0;i<game.players.length;i++){
+							if(game.players[i].type!='human'){
+								game.players[i].init(list[game.players[i].identity+game.players[i].type].randomRemove());
+							}
+						}
+						dialog=ui.create.dialog('选择角色',[list[game.me.identity+'list'].randomGets(8),'character']);
+						ui.create.cheat=function(){
+							_status.createControl=ui.cheat2;
+							ui.cheat=ui.create.control('更换',function(){
+								if(ui.cheat2&&ui.cheat2.dialog==_status.event.dialog){
+									return;
+								}
+								if(game.changeCoin){
+									game.changeCoin(-3);
+								}
+								_status.event.dialog.close();
+								_status.event.dialog=ui.create.dialog('选择角色',[list[game.me.identity+'list'].randomGets(8),'character']);
+								game.uncheck();
+								game.check();
+							});
+							delete _status.createControl;
+						}
+						event.dialogxx=ui.create.characterDialog(function(name){
+							if(lib.character[name][4]){
+								if(lib.character[name][4].contains('jiangeboss')) return true;
+								if(lib.character[name][4].contains('jiangemech')) return true;
+							}
+							if(lib.character[name][1]!=game.me.identity) return true;
+						});
+						ui.create.cheat2=function(){
+							ui.cheat2=ui.create.control('自由选将',function(){
+								if(this.dialog==_status.event.dialog){
+									if(game.changeCoin){
+										game.changeCoin(50);
+									}
+									this.dialog.close();
+									_status.event.dialog=this.backup;
+									this.backup.open();
+									delete this.backup;
+									game.uncheck();
+									game.check();
+									if(ui.cheat){
+										ui.cheat.style.opacity=1;
+									}
+								}
+								else{
+									if(game.changeCoin){
+										game.changeCoin(-10);
+									}
+									this.backup=_status.event.dialog;
+									_status.event.dialog.close();
+									_status.event.dialog=_status.event.parent.dialogxx;
+									this.dialog=_status.event.dialog;
+									this.dialog.open();
+									game.uncheck();
+									game.check();
+									if(ui.cheat){
+										ui.cheat.style.opacity=0.6;
+									}
+								}
+							});
+						}
+						if(!ui.cheat&&get.config('change_choice')) ui.create.cheat();
+						if(!ui.cheat2&&get.config('free_choose')) ui.create.cheat2();
+						break;
+					case 'mech':
+						dialog=ui.create.dialog('选择角色',[list[game.me.identity+'mech'],'character']);
+						break;
+					case 'boss':
+						for(var i=0;i<game.players.length;i++){
+							if(game.players[i].type=='mech'){
+								game.players[i].init(list[game.players[i].identity+game.players[i].type].randomRemove());
+							}
+						}
+						dialog=ui.create.dialog('选择角色',[list[game.me.identity+'boss'],'character']);
+						break;
+				}
+				game.me.chooseButton(dialog,true);
+				'step 1'
+				if(ui.cheat){
+					ui.cheat.close();
+					delete ui.cheat;
+				}
+				if(ui.cheat2){
+					ui.cheat2.close();
+					delete ui.cheat2;
+				}
+				game.me.init(result.links[0]);
+				for(var i=0;i<game.players.length;i++){
+					if(game.players[i].name) continue;
+					if(game.players[i].type!='human'){
+						game.players[i].init(event.list[game.players[i].identity+game.players[i].type].randomRemove());
+					}
+					else{
+						game.players[i].init(event.list[game.players[i].identity+'list'].randomRemove());
+					}
+				}
+			};
+		},
+		chooseCharacterFour:function(){
+			var next=game.createEvent('chooseCharacter',false);
+			next.ai=function(player,list,list2){
+				if(player.identity=='zhu'){
+					list2.randomSort();
+					var choice;
+					if(Math.random()-0.8<0&&list2.length){
+						choice=list2[0];
+					}
+					else{
+						choice=list[0];
+					}
+					player.init(choice);
+					player.hp++;
+					player.maxHp++;
+					player.update();
+				}
+				else if(Math.random()<0.5){
+					var choice=0;
+					for(var i=0;i<list.length;i++){
+						if(lib.character[list[i]][1]==game[player.side+'Zhu'].group){
+							choice=i;break;
+						}
+					}
+					player.init(list[choice]);
+				}
+				else{
+					player.init(list[0]);
+				}
+				this.list.remove(player.name);
+				this.list2.remove(player.name);
+			}
+			next.content=function(){
+				"step 0"
+				var i;
+				var list;
+				var list2=[];
+
+				event.list=[];
+				event.filterChoice=function(name){
+					if(get.config('enable_all')) return false;
+					if(['yuanshu','re_yuanshu','zhangxingcai','hetaiyou','wenpin','yuji','sunluyu',
+					'sp_zhaoyun','sp_diaochan','sp_pangtong','sp_caoren'].contains(name)){
+						return true;
+					}
+					if(lib.characterPack.refresh[name]) return false;
+					if(lib.characterPack.standard[name]){
+						if(lib.characterPack.refresh['re_'+name]) return true;
+						return false;
+					}
+					if(lib.characterPack.shenhua[name]) return false;
+					if(lib.characterPack.sp[name]) return false;
+					if(lib.characterPack.yijiang[name]) return false;
+					return true;
+				}
+				for(i in lib.character){
+					if(event.filterChoice(i)) continue;
+					if(lib.character[i][4]&&lib.character[i][4].contains('forbidai')) continue;
+					if(lib.config.forbidai.contains(i)) continue;
+					if(lib.config.forbidall.contains(i)) continue;
+					if(lib.config.banned.contains(i)) continue;
+					if(!get.config('double_character')&&get.config('ban_weak')&&
+					(lib.config.forbidsingle.contains(i)||lib.rank.c.contains(i)||lib.rank.d.contains(i))) continue;
+					if(get.config('ban_strong')&&(lib.rank.s.contains(i)||lib.rank.ap.contains(i))) continue;
+					if(get.config('double_character')&&lib.config.forbiddouble.contains(i)) continue;
+					event.list.push(i);
+					if(lib.character[i][4]&&lib.character[i][4].contains('zhu')){
+						list2.push(i);
+					}
+				}
+				event.list.randomSort();
+				event.list2=list2;
+				event.current=game.players.randomGet();
+				_status.firstAct=event.current;
+				event.four_assign=get.config('four_assign');
+				event.flipassign=true;
+				"step 1"
+				if(event.current==game.me||(event.four_assign&&event.current.side==game.me.side)){
+					var dialog=event.xdialog||ui.create.characterDialog(event.filterChoice);
+					var names=[];
+					for(var i=0;i<game.players.length;i++){
+						if(game.players[i].name){
+							names.push(game.players[i].name);
+						}
+					}
+					for(var i=0;i<dialog.buttons.length;i++){
+						if(names.contains(dialog.buttons[i].link)){
+							dialog.buttons[i].classList.add('unselectable');
+							dialog.buttons[i].classList.add('noclick');
+						}
+					}
+					if(!event.groupControl){
+						event.groupControl=ui.create.groupControl(dialog);
+					}
+					game.me.chooseButton(dialog,true).closeDialog=false;
+					event.xdialog=dialog;
+					dialog.static=true;
+					event.current.classList.add('selectedx');
+				}
+				else{
+					event.ai(event.current,event.list.randomGets(3),event.list2);
+					if(!event.four_assign){
+						event.current=event.current.next;
+						event.redo();
+					}
+				}
+				"step 2"
+				event.current.classList.remove('selectedx');
+				if(event.current.side==game.me.side){
+					event.current.init(result.buttons[0].link);
+					event.list.remove(event.current.name);
+					event.list2.remove(event.current.name);
+					if(event.current.identity=='zhu'){
+						event.current.hp++;
+						event.current.maxHp++;
+						event.current.update();
+					}
+				}
+				if(event.four_assign){
+					for(var i=0;i<game.players.length;i++){
+						if(!game.players[i].name) break;
+					}
+					if(i<game.players.length){
+						var side=event.current.side;
+						event.current=_status.firstAct;
+						if(event.flipassign){
+							for(var iwhile=0;iwhile<8;iwhile++){
+								event.current=event.current.next;
+								if(event.current.side!=side&&!event.current.name){
+									break;
+								}
+							}
+						}
+						else{
+							for(var iwhile=0;iwhile<8;iwhile++){
+								event.current=event.current.previous;
+								if(event.current.side==side&&!event.current.name){
+									break;
+								}
+							}
+						}
+						event.flipassign=!event.flipassign;
+						event.goto(1);
+					}
+				}
+				else{
+					for(var i=0;i<game.players.length;i++){
+						if(!game.players[i].name){
+							event.ai(game.players[i],event.list.splice(0,3),event.list2);
+						}
+					}
+				}
+				"step 3"
+				if(event.groupControl){
+					event.groupControl.close();
+				}
+				if(event.xdialog){
+					event.xdialog.close();
 				}
 			}
 		},
@@ -664,20 +1089,6 @@ mode.versus={
 					// ui.fakemebg.show();
 					game.onSwapControl();
 				}
-
-				var players=get.players(lib.sort.position);
-				var info=[];
-				for(var i=0;i<players.length;i++){
-					info.push({
-						name:players[i].name,
-						name2:players[i].name2,
-						identity:players[i].node.identity.firstChild.innerHTML,
-						color:players[i].node.identity.dataset.color
-					});
-				}
-				_status.videoInited=true,
-				info.bool=(lib.storage.single_control&&lib.storage.control_all&&game.players.length>=4);
-				game.addVideo('init',null,info);
 			}
 		},
 		versusPhaseLoop:function(player){
@@ -729,6 +1140,21 @@ mode.versus={
 				event.goto(0);
 			}
 		},
+		phaseLoopJiange:function(){
+			var next=game.createEvent('phaseLoop');
+			next.num=0;
+			next.content=function(){
+				if(event.num>=8){
+					event.num-=8;
+				}
+				var player=_status.actlist[event.num];
+				if(player.isAlive()){
+					player.phase();
+				}
+				event.num++;
+				event.redo();
+			}
+		},
 		replacePlayer:function(player){
 			var next=game.createEvent('replacePlayer');
 			next.source=player;
@@ -1110,6 +1536,8 @@ mode.versus={
 		},
 	},
 	translate:{
+		zhu:'主',
+		zhong:'忠',
 		trueZhu:"帅",
 		falseZhu:"将",
 		trueZhong:"兵",
@@ -1183,6 +1611,40 @@ mode.versus={
 				}
 			},
 			dieAfter:function(source){
+				if(_status.mode=='four'){
+					if(this.identity=='zhu'){
+						game.over(this.side!=game.me.side);
+					}
+					else if(source){
+						if(source.side==this.side){
+							if(source.identity=='zhu'){
+								source.discard(source.get('he'));
+							}
+						}
+						else{
+							var num1=0,num2=1;
+							for(var i=0;i<game.players.length;i++){
+								if(game.players[i].side==source.side){
+									num1++;
+								}
+								else{
+									num2++;
+								}
+							}
+							source.draw(2+Math.max(0,num2-num1));
+						}
+					}
+					return;
+				}
+				else if(_status.mode=='jiange'){
+					if(get.population('wei')==0){
+						game.over(game.me.identity=='shu');
+					}
+					else if(get.population('shu')==0){
+						game.over(game.me.identity=='wei');
+					}
+					return;
+				}
 				this.dieSpeak();
 				if(this.side==game.me.side){
 					_status.friendDied.push(this.name);
@@ -1237,10 +1699,10 @@ mode.versus={
 		get:{
 			attitude:function(from,to){
 				if(from.side==to.side){
-					if(to.identity=='zhu'&&lib.storage.main_zhu) return 10;
+					if(to.identity=='zhu'&&(lib.storage.main_zhu||_status.mode=='four')) return 10;
 					return 6;
 				}
-				if(to.identity=='zhu'&&lib.storage.main_zhu) return -10;
+				if(to.identity=='zhu'&&(lib.storage.main_zhu||_status.mode=='four')) return -10;
 				return -6;
 			},
 		}