Merge pull request #15 from kuangshen04/PR-Branch

1

card/standard.js

@@ -760,6 +760,32 @@ game.import('card',function(lib,game,ui,get,ai,_status){
 					}
 					"step 2"
 					ui.clear();
+					var cards;
+					if(card.storage&&Array.isArray(card.storage.fixedShownCards)){
+						cards=card.storage.fixedShownCards.slice();
+						var lose_list=[],cards2=[];
+						cards.forEach(card=>{
+							var owner=get.owner(card);
+							if(owner){
+								var arr=lose_list.find(i=>i[0]==owner);
+								if(arr) arr[1].push(card);
+								else lose_list.push([owner,[card]]);
+							}
+							else cards2.add(card);
+						});
+						if(lose_list.length){
+							lose_list.forEach(list=>{
+								list[0].$throw(list[1]);
+								game.log(list[0],'将',list[1],'置于了处理区');
+							})
+							game.loseAsync({
+								lose_list:lose_list,
+							}).setContent('chooseToCompareLose');
+						}
+						if(cards2.length) game.cardsGotoOrdering(cards2);
+						game.delayex();
+					}
+					else{
 						var num;
 						if(event.targets){
 							num=event.targets.length;
@@ -768,8 +794,9 @@ game.import('card',function(lib,game,ui,get,ai,_status){
 							num=game.countPlayer();
 						}
 						if(card.storage&&typeof card.storage.extraCardsNum=='number') num+=card.storage.extraCardsNum;
-					var cards=get.cards(num);
+						cards=get.cards(num);
 						game.cardsGotoOrdering(cards).relatedEvent=event.getParent();
+					}
 					var dialog=ui.create.dialog('五谷丰登',cards,true);
 					_status.dieClose.push(dialog);
 					dialog.videoId=lib.status.videoId++;
@@ -2735,7 +2762,7 @@ game.import('card',function(lib,game,ui,get,ai,_status){
 					next.set('ai',function(card){
 						var evt=_status.event.getTrigger();
 						if(get.attitude(evt.player,evt.target)<0){
-							if(player.needsToDiscard()) return 15-get.value(card);
+							if(evt.player.needsToDiscard()) return 15-get.value(card);
 							if(evt.baseDamage+evt.extraDamage>=Math.min(2,evt.target.hp)) return 8-get.value(card);
 							return 5-get.value(card);
 						}

character/clan.js

@@ -24,18 +24,178 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			clan_xunyou:['male','wei',3,['clanbaichu','clandaojie'],['clan:颍川荀氏']],
 			clan_wuqiao:['male','jin',4,['clanqiajue','clanmuyin'],['clan:陈留吴氏']],
 			clan_wangguang:['male','wei',3,['clanlilun','clanjianji','clanzhongliu'],['clan:太原王氏']],
+			clan_wangmingshan:['male','wei',3,['clantanque','clanshengmo','clanzhongliu'],['clan:太原王氏']],
 		},
 		characterSort:{
 			clan:{
 				clan_wu:['clan_wuxian','clan_wuban','clan_wukuang','clan_wuqiao'],
 				clan_xun:['clan_xunshu','clan_xunchen','clan_xuncai','clan_xuncan','clan_xunyou'],
 				clan_han:['clan_hanshao','clan_hanrong'],
-				clan_wang:['clan_wangling','clan_wangyun','clan_wanghun','clan_wanglun','clan_wangguang'],
+				clan_wang:['clan_wangling','clan_wangyun','clan_wanghun','clan_wanglun','clan_wangguang','clan_wangmingshan'],
 				clan_zhong:['clan_zhongyan','clan_zhonghui','clan_zhongyu'],
 			},
 		},
 		/** @type { importCharacterConfig['skill'] } */
 		skill:{
+			//族王明山
+			clantanque:{
+				audio:2,
+				trigger:{player:'useCardAfter'},
+				usable:1,
+				filter(event,player){
+					const evt=lib.skill.dcjianying.getLastUsed(player,event);
+					if(!evt||!evt.card) return false;
+					const curCard=event.card,prevCard=evt.card;
+					const curNum=get.number(curCard),prevNum=get.number(prevCard);
+					if(typeof curNum!='number'||typeof prevNum!='number') return false;
+					const delNum=Math.abs(curNum-prevNum);
+					if(delNum===0) return false;
+					return game.hasPlayer(current=>{
+						return current.getHp()===delNum;
+					});
+				},
+				locked:false,
+				async cost(event,trigger,player){
+					const evt=lib.skill.dcjianying.getLastUsed(player,trigger);
+					const curCard=trigger.card,prevCard=evt.card;
+					const curNum=get.number(curCard),prevNum=get.number(prevCard);
+					const delNum=Math.abs(curNum-prevNum);
+					event.result=await player.chooseTarget(get.prompt('clantanque'),`对一名体力值为${delNum}的角色造成1点伤害`,(card,player,target)=>{
+						return target.getHp()===get.event('delNum');
+					}).set('delNum',delNum).set('ai',target=>{
+						return get.damageEffect(target,get.player(),get.player());
+					}).forResult();
+				},
+				async content(event,trigger,player){
+					const target=event.targets[0];
+					await target.damage();
+					await game.asyncDelayx();
+				},
+				mod:{
+					aiOrder(player,card,num){
+						if(typeof card!='object') return;
+						const evt=lib.skill.dcjianying.getLastUsed(player);
+						if(!evt||!evt.card) return;
+						const curNum=get.number(card),prevNum=get.number(evt.card);
+						if(typeof curNum!='number'||typeof prevNum!='number') return;
+						const pairs=game.filterPlayer().map(current=>{
+							return [current.getHp(),get.damageEffect(current,player,player)];
+						}).filter(pair=>pair[1]>0);
+						if(!pairs.length) return;
+						const delNum=Math.abs(curNum-prevNum);
+						for(const [hp,eff] of pairs){
+							if(hp!=delNum) continue;
+							return num+10+(pairs.filter(pair=>pair[0]===hp).sort((a,b)=>b[1]-a[1])[0][1])/20;
+						}
+					},
+				}
+			},
+			clanshengmo:{
+				audio:2,
+				enable:'chooseToUse',
+				hiddenCard(player,name){
+					if(get.type(name)!='basic') return false;
+					if(!player.getStorage('clanshengmo').includes(name)&&(get.event('clanshengmo_cards')||[]).length>0) return true;
+				},
+				filter(event,player){
+					if(event.responded) return false;
+					const names=lib.inpile.filter(name=>get.type(name)=='basic'&&!player.getStorage('clanshengmo').includes(name)),cards=get.event('clanshengmo_cards')||[];
+					return cards.length>0&&names.some(name=>{
+						return event.filterCard({name,isCard:true},player,event);
+					});
+				},
+				onChooseToUse(event){
+					if(game.online) return;
+					if(!event.clanshengmo_cards){
+						let cards=[];
+						game.checkGlobalHistory('cardMove',evt=>{
+							if(evt.name!='cardsDiscard'&&(evt.name!='lose'||evt.position!=ui.discardPile)) return;
+							cards.addArray(evt.cards.filter(card=>get.position(card,true)=='d'));
+						});
+						const numbers=cards.map(card=>get.number(card,false)).unique();
+						const [min,max]=[Math.min(...numbers),Math.max(...numbers)];
+						event.set('clanshengmo_cards',cards.filter(card=>{
+							const num=get.number(card,false);
+							return num>min&&num<max;
+						}));
+					}
+				},
+				async content(event,trigger,player){
+					const evt = event.getParent(2);
+					const names = lib.inpile.filter(name => get.type(name) == 'basic' && !player.getStorage('clanshengmo').includes(name)), cards = evt.clanshengmo_cards;
+					const links = await player.chooseButton(['剩墨：获得其中一张牌', cards], true).set('ai', button => {
+						return get.value(button.link);
+					}).forResultLinks();
+					if (!links || !links.length) return;
+					const list = [];
+					for (const name of names) {
+						const card = { name, isCard: true };
+						if (evt.filterCard(card, player, evt)) {
+							list.push(['基本', '', name]);
+						}
+						if (name == 'sha') {
+							for (const nature of lib.inpile_nature) {
+								card.nature = nature;
+								if (evt.filterCard(card, player, evt)) {
+									list.push(['基本', '', name, nature]);
+								}
+							}
+						}
+					}
+					if (!list.length) return;
+					const links2 = await player.chooseButton(['视为使用一张未以此法使用过的基本牌', [list, 'vcard']], true).set('ai', button => {
+						return get.player().getUseValue(button.link) + 1;
+					}).forResultLinks();
+					const name = links2[0][2], nature = links2[0][3];
+					game.broadcastAll((name, nature, toGain) => {
+						lib.skill.clanshengmo_backup.viewAs = {
+							name,
+							nature,
+							isCard: true,
+						};
+						lib.skill.clanshengmo_backup.prompt = `选择${get.translation(nature)}【${get.translation(name)}】的目标`;
+						lib.skill.clanshengmo_backup.cardToGain = toGain;
+					}, name, nature, links[0]);
+					evt.set('_backupevent', 'clanshengmo_backup');
+					evt.backup('clanshengmo_backup');
+					evt.set('openskilldialog', `选择${get.translation(nature)}【${get.translation(name)}】的目标`);
+					evt.set('norestore', true);
+					evt.set('custom', {
+						add: {},
+						replace: { window() { } }
+					});
+					evt.goto(0);
+				},
+				marktext:'墨',
+				intro:{
+					content:'已以此法使用过$'
+				},
+				subSkill:{
+					backup:{
+						precontent(){
+							delete event.result.skill;
+							event.result.card.storage.clanshengmo = true;
+							player.markAuto('clanshengmo',event.result.card.name);
+							player.gain(lib.skill.clanshengmo_backup.cardToGain, 'gain2');
+						},
+						filterCard:()=>false,
+						selectCard:-1,
+					},
+				},
+				ai:{
+					order:3,
+					result:{
+						player(player){
+							if(get.event().dying) return get.attitude(player, get.event().dying);
+							if(get.event().type!='phase') return 1;
+							const names=get.event(`clanshengmo_${player.playerid}_enabled_names`);
+							return names.some(name=>{
+								return player.getUseValue({name})>0;
+							});
+						}
+					}
+				}
+			},
 			//族贝斯塔[doge]
 			clanlilun:{
 				audio:2,
@@ -575,21 +735,15 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 				content(){
 					'step 0'
 					player.unmarkSkill('clanyuzhi');
-					var num1=0,num2=0,num3=0,bool=true;
+					var num1=player.getRoundHistory('gain',evt=>{
-					var history=player.actionHistory;
+						return evt.getParent().name=='draw'&&evt.getParent(2).name=='clanyuzhi';
-					for(var i=history.length-2;i>=0;i--){
+					},1).reduce((sum,evt)=>sum+evt.cards.length,0);
-						for(var evt of history[i].gain){
+					var num2=player.getRoundHistory('gain',evt=>{
-							if(evt.getParent().name=='draw'&&evt.getParent(2).name=='clanyuzhi'){
+						return evt.getParent().name=='draw'&&evt.getParent(2).name=='clanyuzhi';
-								if(bool) num1+=evt.cards.length;
+					},2).reduce((sum,evt)=>sum+evt.cards.length,0);
-								else num2+=evt.cards.length;
+					var num3=player.getRoundHistory('useCard',evt=>{
-							}
+						return evt.cards&&evt.cards.length;
-						}
+					},1).reduce((sum,evt)=>sum+evt.cards.length,0);
-						if(bool) num3+=history[i].useCard.length;
-						if(history[i].isRound){
-							if(bool) bool=false;
-							else break;
-						}
-					}
 					event.num1=num1;
 					if(num1>0&&(num2>0&&num1>num2)||num1>num3){
 						player.logSkill('clanyuzhi');
@@ -607,15 +761,17 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					'step 2'
 					if(!player.countCards('h')) event.finish();
 					'step 3'
-					player.chooseToDiscard('迂志：请弃置一张手牌','摸此牌牌名字数的牌。下一轮开始时，若本轮你使用的牌数或上一轮你以此法摸的牌数小于此牌牌名字数，则你失去1点体力。',true,function(card,player){
+					player.chooseCard('迂志：请展示一张手牌','摸此牌牌名字数的牌。下一轮开始时，若本轮你使用的牌数或上一轮你以此法摸的牌数小于此牌牌名字数，则你失去1点体力。',function(card,player){
 						var num=get.cardNameLength(card);
 						return typeof num=='number'&&num>0;
-					}).set('logSkill','clanyuzhi').set('ai',function(card){
+					},true).set('logSkill','clanyuzhi').set('ai',function(card){
 						if(_status.event.dying&&_status.event.num>0&&get.cardNameLength(card)>_status.event.num) return 1/get.cardNameLength(card);//怂
 						return get.cardNameLength(card);//勇
 					}).set('dying',player.hp+player.countCards('hs',{name:['tao','jiu']})<1).set('num',event.num1);
 					'step 4'
 					if(result.bool){
+						player.logSkill('clanyuzhi');
+						player.showCards(result.cards,get.translation(player)+'发动了【迂志】');
 						player.draw(get.cardNameLength(result.cards[0]));
 						player.storage.clanyuzhi=get.cardNameLength(result.cards[0]);
 						player.markSkill('clanyuzhi');
@@ -632,7 +788,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 				audio:2,
 				trigger:{player:'damageEnd',source:'damageSource'},
 				filter(event,player){
-					if(!event.card||player.isLinked()) return false;
+					if(!event.card/*||player.isLinked()*/) return false;
 					if(game.getGlobalHistory('everything',evt=>{
 						if(evt.name!='damage'||!evt.card) return false;
 						return evt.player==player||(evt.source&&evt.source==player);
@@ -645,7 +801,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					'step 0'
 					var num=get.cardNameLength(trigger.card),str='';
 					if(player.getDamagedHp()>0) str+=('并摸'+get.cnNumber(player.getDamagedHp())+'张牌');
-					player.chooseToDiscard(get.prompt('clanxieshu'),'横置武将牌，弃置'+get.cnNumber(num)+'张牌'+str,'he',num).set('ai',function(card){
+					player.chooseToDiscard(get.prompt('clanxieshu'),/*'横置武将牌，'+*/'弃置'+get.cnNumber(num)+'张牌'+str,'he',num).set('ai',function(card){
 						var player=_status.event.player;
 						var num=_status.event.num;
 						var num2=player.getDamagedHp();
@@ -655,7 +811,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					}).set('num',num).logSkill='clanxieshu';
 					'step 1'
 					if(result.bool){
-						player.link(true);
+						//player.link(true);
 						if(player.getDamagedHp()>0) player.draw(player.getDamagedHp());
 					}
 				},
@@ -1396,7 +1552,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			},
 			clanzhongliu:{
 				audio:2,
-				audioname:['clan_wangling','clan_wangyun','clan_wanghun','clan_wanglun','clan_wangguang'],
+				audioname:['clan_wangling','clan_wangyun','clan_wanghun','clan_wanglun','clan_wangguang','clan_wangmingshan'],
 				trigger:{player:'useCard'},
 				forced:true,
 				clanSkill:true,
@@ -1555,7 +1711,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 							'step 3'
 							if(result.bool){
 								target.recast(result.cards);
-								if(get.color(cards[0])!=get.color(result.cards[0])) lib.skill.chenliuwushi.change(target,-1);
+								if(get.color(cards[0])===get.color(result.cards[0])) lib.skill.chenliuwushi.change(target,1);
 							}
 							event.finish();
 							'step 4'
@@ -1588,7 +1744,18 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 							if(result.bool) cards.push(result.card);
 							if(targets.length>0) event.goto(6);
 							'step 8'
-							if(cards.length>1&&get.color(cards)!='none') lib.skill.chenliuwushi.change(target,1);
+							if (cards.length > 1) {
+								const color = get.color(cards[0], false);
+								if (color != 'none') {
+									for (let i = 1; i < cards.length; i++) {
+										const color2 = get.color(cards[i], false);
+										if (color !== color2 && color2 !== 'none') {
+											lib.skill.chenliuwushi.change(target, -1);
+											break;
+										}
+									}
+								}
+							}
 						},
 						ai:{
 							order:4.1,
@@ -1989,16 +2156,8 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 				forced:true,
 				filter(event,player){
 					if(!game.hasPlayer(current=>current!=player)) return false;
-					var card=event.card,type=get.type2(card);
+					const type=get.type2(event.card);
-					for(var i=player.actionHistory.length-1; i>=0; i--){
+					return player.getRoundHistory('useCard',evt=>get.type2(evt.card)==type).indexOf(event)==0;
-						var history=player.actionHistory[i].useCard;
-						for(var evt of history){
-							if(evt==event) continue;
-							if(get.type2(evt.card)==type) return false;
-						}
-						if(player.actionHistory[i].isRound) break;
-					}
-					return true;
 				},
 				getNum(player){
 					return (player.countCards('ej')>0)+(player.isDamaged())+(Math.max(0,player.hp)<player.countCards('h'));
@@ -2482,23 +2641,15 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 				audio:2,
 				intro:{
 					content:'已使用过的花色：$',
-					onunmark:true
+					onunmark:true,
 				},
 				trigger:{player:'useCardAfter'},
 				forced:true,
 				filter(event,player){
 					if(!lib.suit.includes(get.suit(event.card))) return false;
-					var card=event.card,suit=get.suit(card);
+					const suit=get.suit(event.card);
-					for(var i=player.actionHistory.length-1; i>=0; i--){
+					if(player.getRoundHistory('useCard',evt=>get.suit(evt.card)==suit).indexOf(event)!=0) return false;
-						var history=player.actionHistory[i].useCard;
+					return event.targets&&event.targets.length==1&&!event.targets[0].isLinked()||player.hasCard(card=>get.suit(card)==get.suit(event.card)&&player.canRecast(card),'h');
-						for(var evt of history){
-							if(evt==event) continue;
-							if(get.suit(evt.card)==suit) return false;
-						}
-						if(player.actionHistory[i].isRound) break;
-					}
-					return event.targets&&event.targets.length==1&&!event.targets[0].isLinked()||
-						player.hasCard(card=>get.suit(card)==get.suit(event.card)&&player.canRecast(card),'h');
 				},
 				content(){
 					'step 0'
@@ -2514,37 +2665,49 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					'step 1'
 					if(event.link&&event.recast) player.draw();
 				},
-				group:['clandianzhan_count','clandianzhan_clear'],
+				group:'clandianzhan_count',
 				subSkill:{
 					count:{
+						charlotte:true,
 						trigger:{player:'useCardAfter'},
 						filter(event,player){
 							let suit=get.suit(event.card);
 							return lib.suits.includes(suit)&&!player.getStorage('clandianzhan').includes(suit);
 						},
+						forced:true,
 						silent:true,
-						charlotte:true,
 						content(){
-							player.storage.clandianzhan=[];
+							let suits=player.getRoundHistory('useCard',evt=>{
-							for(let i=player.actionHistory.length-1; i>=0; i--){
+								return lib.suits.includes(get.suit(evt.card));
-								let history=player.actionHistory[i].useCard;
+							}).reduce((list,evt)=>{
-								for(let evt of history){
+								return list.add(get.suit(evt.card));
-									player.storage.clandianzhan.add(get.suit(evt.card));
+							},[]).sort((a,b)=>lib.suits.indexOf(a)-lib.suits.indexOf(b));
-								}
+							if(!player.storage.clandianzhan){
-								if(player.actionHistory[i].isRound) break;
+								player.when({global:'roundStart'}).then(()=>{
+									delete player.storage.clandianzhan;
+									player.unmarkSkill('clandianzhan');
+								});
 							}
+							player.storage.clandianzhan=suits;
 							player.markSkill('clandianzhan');
 						},
-						sub:true
 					},
-					clear:{
+				},
-						trigger:{global:'roundStart'},
+				init(player){
-						silent:true,
+					let suits=player.getRoundHistory('useCard',evt=>{
-						charlotte:true,
+						return lib.suits.includes(get.suit(evt.card));
-						content(){
+					}).reduce((list,evt)=>{
+						return list.add(get.suit(evt.card));
+					},[]).sort((a,b)=>lib.suits.indexOf(a)-lib.suits.indexOf(b));
+					if(suits.length){
+						if(!player.storage.clandianzhan){
+							player.when({global:'roundStart'}).then(()=>{
+								delete player.storage.clandianzhan;
 								player.unmarkSkill('clandianzhan');
-						},
+							});
-						sub:true
+						}
+						player.storage.clandianzhan=suits;
+						player.markSkill('clandianzhan');
 					}
 				}
 			},
@@ -2829,6 +2992,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			wanglun:'王沦（233年－257年）字太冲，出身太原晋阳王姓世族（今山西省太原市），王昶三子，王浑、王深之弟，王湛之兄。醇粹简远，崇尚老庄之学，心思平淡。二十多时被举荐为孝廉，没有前往，后任大将军参军。257年，诸葛诞不满司马氏篡权而在寿春起义，王沦跟随司马昭征讨，遭遇疾疫去世，时年二十五，时人惜之，司马昭为他流泪。其兄著诔文《表德论》，表述其德行，说“因为畏惧帝王的典章制度，不能写墓志铭，于是撰写过往的事迹，刻在墓的背面。”',
 			wuqiao:'吴乔，西晋人物，蜀车骑将军吴懿之孙。李雄建立成汉政权，他沦落益州，长达三十年，始终不向李雄屈服。',
 			clan_wangguang:'王广，三国时期曹魏太原祁县人，哲学家。东汉司徒王允从孙，魏太尉王凌之子。有志尚学，官至尚书。魏时随父亲在朝作官，屯骑校尉，机智有谋。当得知司马懿篡夺曹魏政权时，王凌与外甥令狐愚合谋立楚王为魏主，王广劝其父不可，王凌没有接受儿子的谏言，结果计谋泄而被害。',
+			wangmingshan:'王明山，王凌的小儿子，太原祁（今山西省祁县）人，三国魏书法家，最知名善画，多技艺，人得其书，皆以为法。太尉王凌参与谋划废立，事情泄露，被太傅司马懿领兵平定。',
 		},
 		dynamicTranslate:{
 			clanlianzhu(player){
@@ -2915,7 +3079,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			clanhuanjia_info:'出牌阶段结束时，你可以与一名角色拼点。赢的角色可以使用一张拼点牌。然后若此牌：未造成过伤害，你获得另一张拼点牌；造成过伤害，你失去一个技能。',
 			clan_wukuang:'族吴匡',
 			clanlianzhu:'联诛',
-			clanlianzhu_info:'转换技。每名角色Ａ的出牌阶段限一次。阴：Ａ可以重铸一张牌，然后你可以重铸一张牌。若这两张牌颜色不同，则你的手牌上限-1；阳：Ａ可以令你选择一名在你或Ａ攻击范围内的另一名其他角色Ｂ，然后Ａ和你可依次选择是否对Ｂ使用一张【杀】。若这两张【杀】颜色相同，则你的手牌上限+1。',
+			clanlianzhu_info:'转换技。每名角色Ａ的出牌阶段限一次。阴：Ａ可以重铸一张牌，然后你可以重铸一张牌。若这两张牌颜色相同，则你的手牌上限+1；阳：Ａ可以令你选择一名在你或Ａ攻击范围内的另一名其他角色Ｂ，然后Ａ和你可依次选择是否对Ｂ使用一张【杀】。若这两张【杀】颜色不同，则你的手牌上限-1。',
 			clan_wangling:'族王淩',
 			clanbolong:'驳龙',
 			clanbolong_info:'出牌阶段限一次。你可以令一名其他角色选择一项：1.你交给其一张牌，然后视为对其使用一张雷【杀】；2.交给你等同于你手牌数的牌，然后视为对你使用一张【酒】。',
@@ -2940,9 +3104,9 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			clanchenya_info:'当一名角色发动“出牌阶段限一次”的技能后，你可以令其重铸任意张牌名字数为X的牌（X为其手牌数）。',
 			clan_zhonghui:'族钟会',
 			clanyuzhi:'迂志',
-			clanyuzhi_info:'锁定技。新的一轮开始时，你依次执行以下项：①若你上一轮使用的牌数或你上上轮因〖迂志〗摸的牌数小于你上轮因〖迂志〗摸的牌数，你失去1点体力或失去〖保族〗。②你弃置一张手牌，然后摸X张牌（X为此牌牌名字数）。',
+			clanyuzhi_info:'锁定技。新的一轮开始时，你依次执行以下项：①若你上一轮使用的牌数或你上上轮因〖迂志〗摸的牌数小于你上轮因〖迂志〗摸的牌数，你失去1点体力或失去〖保族〗。②你展示一张手牌，然后摸X张牌（X为此牌牌名字数）。',
 			clanxieshu:'挟术',
-			clanxieshu_info:'当你每回合首次因牌造成或受到伤害后，你可以横置武将牌，然后弃置Y张牌并摸你已损失体力值张牌（Y为此牌牌名字数）。',
+			clanxieshu_info:'当你每回合首次因牌造成或受到伤害后，你可以弃置Y张牌并摸你已损失体力值张牌（Y为此牌牌名字数）。',
 			clan_zhongyu:'族钟毓',
 			clanjiejian:'捷谏',
 			clanjiejian_info:'当你于一回合使用第X张牌指定第一个目标后，若此牌不为装备牌，则你可以令一名目标角色摸X张牌。（X为此牌牌名字数）',
@@ -2965,6 +3129,12 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			clanlilun_info:'出牌阶段限一次，你可以重铸两张手牌（不能是你本回合以此法重铸过的牌名的牌），然后使用其中的一张牌。',
 			clanjianji:'见机',
 			clanjianji_info:'限定技，一名角色的结束阶段，若其上下家均未于本回合：使用过牌，则你可以与其各摸一张牌；成为过牌的目标，则你可以视为使用一张【杀】。',
+			clan_wangmingshan:'族王明山',
+			clan_wangmingshan_prefix:'族',
+			clantanque:'弹雀',
+			clantanque_info:'每回合限一次。当你使用牌结算结束后，你可以对一名体力值为X且不为0的角色造成1点伤害（X为此牌点数与你上一张使用的牌的点数之差）。',
+			clanshengmo:'剩墨',
+			clanshengmo_info:'当你需要使用一张未以此法使用过的基本牌时，你可以获得一张于本回合进入弃牌堆且点数不为这些牌中最大且不为这些牌中最小的牌，视为你使用需要使用的牌。',
 
 			clan_wu:'陈留·吴氏',
 			clan_xun:'颍川·荀氏',

character/extra.js

@@ -13,7 +13,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 				extra_yin:['shen_liubei','shen_luxun'],
 				extra_lei:['shen_ganning','shen_zhangliao'],
 				extra_key:['key_kagari','key_shiki','db_key_hina'],
-				extra_decade:['shen_jiangwei','shen_machao','shen_zhangfei','shen_zhangjiao','shen_dengai','shen_xuzhu'],
+				extra_decade:['shen_jiangwei','shen_machao','shen_zhangfei','shen_zhangjiao','shen_dengai','shen_xuzhu','dc_shen_huatuo'],
 				extra_ol:['ol_zhangliao','shen_caopi','shen_zhenji','shen_sunquan'],
 				extra_mobilezhi:['shen_guojia','shen_xunyu'],
 				extra_mobilexin:['shen_taishici','shen_sunce'],
@@ -23,6 +23,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			},
 		},
 		character:{
+			dc_shen_huatuo:['male','shen',3,['jingyu','lvxin','huandao'],['qun']],
 			shen_xuzhu:['male','shen',5,['zhengqing','zhuangpo'],['wei']],
 			shen_lusu:['male','shen',3,['dingzhou','tamo','zhimeng'],['wu']],
 			shen_huatuo:['male','shen',3,['wuling','youyi'],['qun']],
@@ -79,6 +80,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			shen_jiaxu:['le_shen_jiaxu','shen_jiaxu'],
 			shen_caocao:['shen_caocao','old_caocao'],
 			shen_zhangjiao:['shen_zhangjiao','junk_zhangjiao'],
+			shen_huatuo:['dc_shen_huatuo','shen_huatuo'],
 		},
 		characterFilter:{
 			shen_diaochan(mode){
@@ -95,6 +97,217 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 		},
 		/** @type { importCharacterConfig['skill'] } */
 		skill:{
+			//十周年神华佗
+			jingyu:{
+				audio:2,
+				trigger:{
+					global:['useSkill','logSkillBegin','useCard','respond'],
+				},
+				filter(event,player){
+					if(['global','equip'].includes(event.type)) return false;
+					let skill=event.sourceSkill||event.skill;
+					if(!skill||skill==='jingyu') return false;
+					let info=get.info(skill);
+					while(true){
+						if(!info||info.charlotte) return false;
+						if(info&&!info.sourceSkill) break;
+						skill=info.sourceSkill;
+						info=get.info(skill);
+					}
+					return !player.getStorage('jingyu_used').includes(skill);
+				},
+				forced:true,
+				async content(event,trigger,player){
+					if (!player.storage.jingyu_used){
+						player.when({global:'roundStart'}).assign({
+							firstDo: true,
+						}).then(() => delete player.storage.jingyu_used);
+					}
+					player.markAuto('jingyu_used', trigger.sourceSkill || trigger.skill);
+					await player.draw();
+				},
+				ai:{
+					threaten:6,
+				},
+			},
+			lvxin:{
+				audio:2,
+				enable:'phaseUse',
+				usable:1,
+				filterCard:true,
+				filterTarget:lib.filter.notMe,
+				delay:false,
+				discard:false,
+				lose:false,
+				async content(event,trigger,player){
+					const { target, cards } = event, round = Math.min(5, game.roundNumber);
+					const name = get.translation(target);
+					await player.give(cards, target);
+					const result = await player.chooseControl(['摸牌', '弃牌']).set('choiceList', [
+						`令${name}摸${get.cnNumber(round)}张牌`,
+						`令${name}随机弃置${get.cnNumber(round)}张手牌`
+					]).set('prompt', '滤心：请选择一项').forResult();
+					let cards2 = [];
+					if (result.index === 0) {
+						cards2 = await target.draw(round).forResult();
+					}
+					else {
+						const cards = target.getCards('h', card => {
+							return lib.filter.cardDiscardable(card, target, 'lvxin');
+						});
+						if (cards.length > 0){
+							const evt = await target.discard(cards.randomGets(round)).set('discarder', target);
+							cards2 = evt.done.cards2;
+						}
+					}
+					const cardName = get.name(cards[0], player);
+					if (cards2.some(card => {
+						return get.name(card, target) === cardName;
+					})) {
+						target.addSkill('lvxin_lose');
+						target.addMark('lvxin_lose', 1, false);
+					}
+				},
+				subSkill:{
+					lose:{
+						trigger:{
+							player:['useSkill','logSkillBegin','useCard','respond'],
+						},
+						filter(event,player){
+							if(['global','equip'].includes(event.type)) return false;
+							const skill=event.sourceSkill||event.skill;
+							const info=get.info(skill);
+							return info&&!info.charlotte;
+						},
+						forced:true,
+						onremove:true,
+						charlotte:true,
+						async content(event,trigger,player){
+							player.loseHp(player.countMark('lvxin_lose'));
+							player.removeSkill('lvxin_lose');
+						},
+						intro:{
+							content:'下次发动技能时失去#点体力',
+						},
+					}
+				}
+			},
+			huandao:{
+				audio:2,
+				enable:'phaseUse',
+				usable:1,
+				limited:true,
+				filterTarget:lib.filter.notMe,
+				skillAnimation:true,
+				animationColor:'metal',
+				async content(event,trigger,player){
+					player.awakenSkill('huandao');
+					const { target } = event;
+					await target.turnOver(false);
+					await target.link(false);
+					let names = [target.name1||target.name];
+					if (target.name2) names.add(target.name2);
+					names = names.map(name => get.rawName(name));
+					if (!_status.characterlist) lib.skill.pingjian.initList();
+					_status.characterlist.randomSort();
+					let ownedSkills = target.getSkills(null, false, false), ownedSkillsName = ownedSkills.map(skill => get.translation(skill));
+					let skillToGain = null;
+					outer: for (const name of _status.characterlist){
+						const info = lib.character[name];
+						if (!names.includes(get.rawName(name))) continue;
+						const skills = info[3].slice().randomSort();
+						while (skills.length) {
+							const skill = skills.shift(), skillName = get.translation(skill);
+							if (!ownedSkillsName.includes(skillName)) {
+								skillToGain = skill; 
+								break outer;
+							}
+						}
+					}
+					if (!skillToGain) return;
+					player.popup(skillToGain);
+					player.line(target, 'green');
+					let prompt2 = '若你选择是，则你于获得此技能后须失去一个其他技能。<br><br>';
+					if(lib.skill[skillToGain].nobracket){
+						prompt2 += `<div class="skilln">${get.translation(skillToGain)}</div><div><span style="font-family: yuanli">${get.skillInfoTranslation(skillToGain)}</span></div><br><br>`;
+					}
+					else{
+						const translation=lib.translate[skillToGain+'_ab'] || get.translation(skillToGain).slice(0, 2);
+						prompt2 += `<div class="skill">【${translation}】</div><div><span style="font-family: yuanli">${get.skillInfoTranslation(skillToGain)}</span></div><br><br>`;
+					}
+					const bool = await target.chooseBool(`寰道：是否获得技能〖${get.translation(skillToGain)}〗？`, prompt2)
+						.set('choice', (() => {
+							const rank = get.skillRank(skillToGain, 'inout') + 1;
+							return ownedSkills.some(skill => {
+								const info = get.info(skill);
+								if (info) {
+									if (target.awakenedSkills.includes(skill) && (info.limited || info.juexingji || info.dutySkill)) return true;
+									if (info.ai && (info.ai.neg || info.ai.halfneg)) return true;
+								}
+								return get.skillRank(skill, 'inout') < rank;
+							});
+						})())
+						.forResultBool();
+					if (!bool) {
+						target.chat('拒绝');
+						game.log(target, '拒绝获得技能', `#g【${get.translation(skillToGain)}】`)
+						await game.asyncDelay();
+						return;
+					}
+					await target.addSkills(skillToGain);
+					ownedSkills = target.getSkills(null, false, false).filter(skill => {
+						if (skill === skillToGain) return false;
+						const info = get.info(skill);
+						if(!info || info.charlotte || !get.skillInfoTranslation(skill, player).length) return false;
+						return true;
+					});
+					if (!ownedSkills) return;
+					const control = await target.chooseControl(ownedSkills).set('choiceList', ownedSkills.map(skill => {
+						return `<div class="skill">【${get.translation(lib.translate[skill + '_ab'] || get.translation(skill).slice(0, 2))}】</div><div>${get.skillInfoTranslation(skill, target)}</div>`;
+					})).set('displayIndex', false).set('prompt', '寰道：选择失去一个技能').set('ai', () => {
+						return get.event('choice');
+					}).set('choice', (() => {
+						const uselessSkills = ownedSkills.filter(skill => {
+							const info = get.info(skill);
+							if (!info) return false;
+							if (target.awakenedSkills.includes(skill) && (info.limited || info.juexingji || info.dutySkill)) return true;
+							if (info.ai && (info.ai.neg || info.ai.halfneg)) return true;
+							return false;
+						});
+						if (uselessSkills.length) return uselessSkills.randomGet();
+						return ownedSkills.sort((a, b) => {
+							return get.skillRank(a, 'inout') - get.skillRank(b, 'inout');
+						})[0];
+					})()).forResultControl();
+					await target.removeSkills(control);
+				},
+				ai:{
+					order:5,
+					result:{
+						target(player,target){
+							if(game.roundNumber*game.countPlayer()<=1.5*game.countPlayer2()/Math.sqrt(player.getDamagedHp()+1)) return 0;
+							const ownedSkills=target.getSkills(null,false,false).filter(skill=>{
+								const info=get.info(skill);
+								if(!info||info.charlotte||!get.skillInfoTranslation(skill,player).length) return false;
+								return true;
+							});
+							const uselessSkills=ownedSkills.filter(skill=>{
+								const info=get.info(skill);
+								if(!info) return false;
+								if(target.awakenedSkills.includes(skill)&&(info.limited||info.juexingji||info.dutySkill)) return true;
+								if(info.ai&&(info.ai.neg||info.ai.halfneg)) return true;
+								return false;
+							});
+							if(uselessSkills.length) return 3;
+							let names=[target.name1||target.name];
+							if(target.name2) names.add(target.name2);
+							names=names.map(name=>get.rawName(name));
+							if(_status.characterlist.some(name=>names.includes(get.rawName(name)))) return 1;
+							return 0;
+						},
+					},
+				},
+			},
 			//神许褚
 			zhengqing:{
 				audio:2,
@@ -7595,70 +7808,65 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			drlt_zhiti:{
 				audio:2,
 				locked:true,
-				group:["drlt_zhiti_1","drlt_zhiti_2","drlt_zhiti_3","drlt_zhiti_4","drlt_zhiti_5"],
+				group:['drlt_zhiti_damage','drlt_zhiti_compare','drlt_zhiti_juedou'],
 				global:'g_drlt_zhiti',
 				subSkill:{
-					'1':{
+					juedou:{
-						audio:"drlt_zhiti",
-						trigger:{
-							global:'juedouAfter'
-						},
-						forced:true,
-						filter(event,player){
-							return event.targets&&event.targets.includes(player)&&event.turn!=player&&player.hasDisabledSlot();
-						},
-						content(){
-							player.chooseToEnable();
-						},
-					},
-					'2':{
 						audio:"drlt_zhiti",
 						trigger:{
 							player:'juedouAfter',
+							target:'juedouAfter',
 						},
 						forced: true,
 						filter(event,player) {
-							return event.turn!=player&&player.hasDisabledSlot();
+							if (event.turn === player || !player.hasDisabledSlot()) return false;
+							const opposite = (event.player === player ? event.target : event.player);
+							return opposite && opposite.isIn() && opposite.inRangeOf(player);
 						},
 						content(){
 							player.chooseToEnable();
 						},
 					},
-					'3':{
+					compare:{
 						audio:"drlt_zhiti",
 						trigger:{
-							player:'chooseToCompareAfter'
+							player:['chooseToCompareAfter','compareMultipleAfter'],
+							target:['chooseToCompareAfter','compareMultipleAfter']
+						},
+						filter(event,player){
+							if (event.preserve || !player.hasDisabledSlot()) return false;
+							let opposite;
+							if (player === event.player){
+								if (event.num1 > event.num2){
+									opposite = event.target;
+								}
+								else {
+									return false;
+								}
+							}
+							else{
+								if (event.num1 < event.num2){
+									opposite = event.player;
+								}
+								else{
+									return false;
+								}
+							}
+							return opposite && opposite.isIn() && opposite.inRangeOf(player);
 						},
 						forced:true,
-						filter(event,player){
-							return event.result.bool==true&&player.hasDisabledSlot();
-						},
-						content(){
-							'step 0'
-							player.chooseToEnable();
-						},
-					},
-					'4':{
-						audio:"drlt_zhiti",
-						trigger:{
-							global:'chooseToCompareAfter'
-						},
-						forced:true,
-						filter(event,player){
-							return (event.targets!=undefined&&event.targets.includes(player)||event.target==player)&&event.result.bool==false&&player.hasDisabledSlot();
-						},
 						content(){
 							player.chooseToEnable();
 						},
 					},
-					'5':{
+					damage:{
-						audio:"drlt_zhiti",
+						audio:'drlt_zhiti',
-						trigger:{
+						trigger:{player:'damageEnd'},
-							player:['damageEnd']
-						},
 						forced:true,
 						filter(event,player) {
-							return player.hasDisabledSlot();
+							if (!player.hasDisabledSlot()) return false;
+							const opposite = event.source;
+							return opposite && opposite.isIn() && opposite.inRangeOf(player);
 						},
 						content(){
 							player.chooseToEnable();
@@ -7669,9 +7877,9 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			g_drlt_zhiti:{
 				mod:{
 					maxHandcard (player,num){
-						if(player.maxHp>player.hp&&game.countPlayer(function(current){
+						if(player.isDamaged()) return num-game.countPlayer(function(current){
 							return current!=player&&current.hasSkill('drlt_zhiti')&&current.inRange(player);
-						})) return num-1;
+						});
 					},
 				},
 			},
@@ -8242,7 +8450,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			"drlt_duorui":"夺锐",
 			"drlt_duorui_info":"当你于出牌阶段内对一名其他角色造成伤害后，你可以废除你装备区内的一个装备栏（若已全部废除则可以跳过此步骤），然后获得该角色的一个技能直到其的下回合结束或其死亡(觉醒技，限定技，主公技，隐匿技，使命技等特殊技能除外)。若如此做，该角色该技能失效且你不能再发动〖夺锐〗直到你失去以此法获得的技能。",
 			"drlt_zhiti":"止啼",
-			"drlt_zhiti_info":"锁定技，你攻击范围内已受伤的其他角色手牌上限-1；当你拼点或【决斗】胜利，或受到伤害后，你恢复一个装备栏。",
+			"drlt_zhiti_info":"锁定技。①你攻击范围内已受伤的其他角色手牌上限-1；②当你拼点或【决斗】胜利/或受到伤害后，若对方/伤害来源在你的攻击范围内，则你恢复一个装备栏。",
 
 			shen_zhaoyun:'神赵云',
 			shen_zhaoyun_prefix:'神',
@@ -8544,8 +8752,8 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			jxlianpo_info:'锁定技。①若场上最大阵营为：反贼，其他角色的手牌上限-1，所有角色使用【杀】的次数上限和攻击范围+1；主忠，其他角色不能对其以外的角色使用【桃】。其他角色死亡后，若有多个最大阵营，来源摸两张牌并回复1点体力。②一轮游戏开始时，你展示一张未加入游戏或已死亡角色的身份牌，本轮视为该身份对应阵营的角色数+1。',
 			jxzhaoluan:'兆乱',
 			jxzhaoluan_info:'限定技。一名角色死亡前，若其此次进入过濒死状态，你可以取消之，令其加3点体力上限并失去所有非锁定技，回复体力至3点，摸四张牌。然后你获得如下效果：出牌阶段，你可以令一名成为过你〖兆乱〗目标的角色减1点体力上限，然后对一名此阶段未以此法选择过的角色造成1点伤害。',
-			shen_huatuo:'神华佗',
+			shen_huatuo:'手杀神华佗',
-			shen_huatuo_prefix:'神',
+			shen_huatuo_prefix:'手杀神',
 			wuling:'五灵',
 			wuling_info:'①出牌阶段限两次。你可以选择一名没有“五禽戏”的角色，按照你选择的顺序向其传授“五禽戏”，且其获得如下效果：其获得你选择的第一种“五禽戏”的效果，并在其每个准备阶段移除当前“五禽戏”的效果并切换为下一种。②当你死亡时，你令场上的角色失去你传授的“五禽戏”。',
 			wuling_wuqinxi:'五禽戏',
@@ -8571,6 +8779,14 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			zhengqing_info:'锁定技。一轮游戏开始时，你移去所有角色的“擎”标记，令上一轮于一回合内造成伤害值最多的角色各获得X枚“擎”，且你与这些角色各摸一张牌（X为这些角色该回合内造成的伤害值）。若该角色为你且本次获得的“擎”数为本局游戏最多的一次，你改为摸X张牌（至多摸五张）。',
 			zhuangpo:'壮魄',
 			zhuangpo_info:'你可以将牌名为【杀】或牌面信息中包含“【杀】”的牌当【决斗】使用，然后你获得如下效果：1.当此【决斗】指定目标后，若你有“擎”，你可以移去任意枚“擎”，令目标角色弃置等量的牌；2.当你造成渠道为此牌的伤害时，若此牌的所有目标角色中存在有“擎”的角色，此伤害+1。',
+			dc_shen_huatuo:'神华佗',
+			dc_shen_huatuo_prefix:'神',
+			jingyu:'静域',
+			jingyu_info:'锁定技。每个技能每轮限一次，当一名角色发动不为〖静域〗的技能时，你摸一张牌。',
+			lvxin:'滤心',
+			lvxin_info:'出牌阶段限一次。你可以交给一名其他角色一张手牌并选择一项：⒈令其摸X张牌；⒉令其随机弃置X张手牌（X为游戏轮数，至多为5）。然后若其以此法得到/弃置了与你交给其的牌牌名相同的牌，其于其下次发动技能时回复/失去1点体力。',
+			huandao:'寰道',
+			huandao_info:'限定技。出牌阶段，你可以选择一名其他角色。你令其复原武将牌，系统随机生成一个与其同名的武将的武将牌上的一个与其拥有的技能均不同名的技能。其可以选择获得此技能，然后选择失去一个其他技能。',
 
 			extra_feng:'神话再临·风',
 			extra_huo:'神话再临·火',

character/huicui.js

@@ -111,8 +111,8 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 				sp_caizijiaren:['dc_kongrong','re_dongbai','re_sunluyu','heyan','zhaoyan','wangtao','wangyue','zhangxuan','tengyin','zhangyao','xiahoulingnv','dc_sunru','pangshanmin','kuaiqi'],
 				sp_zhilan:['dc_liuli','liuyong','wanniangongzhu','zhanghu','lvlingqi','tenggongzhu','panghui','dc_zhaotongzhaoguang','yuantanyuanxiyuanshang','yuechen','dc_lingcao'],
 				sp_guixin:['zangba','re_kanze','re_chendeng','caimaozhangyun','dc_lvkuanglvxiang','dc_gaolan','yinfuren','chengui','chenjiao','dc_sp_jiaxu','qinlang','dc_dongzhao'],
-				sp_daihan:['mamidi','dc_jiling','zhangxun','dc_yuejiu','wanglie','leibo','qiaorui','dongwan','yuanyin'],
+				sp_daihan:['mamidi','dc_jiling','zhangxun','dc_yuejiu','leibo','qiaorui','dongwan','yuanyin'],
-				sp_jianghu:['guanning','huzhao','dc_huangchengyan','mengjie'],
+				sp_jianghu:['guanning','huzhao','dc_huangchengyan','mengjie','wanglie'],
 				sp_zongheng:['huaxin','luyusheng','re_xunchen','re_miheng','fengxi','re_dengzhi','dc_yanghu','zongyu'],
 				sp_taiping:['guanhai','liupi','peiyuanshao','zhangchu','zhangkai','dc_zhangmancheng'],
 				sp_yanhan:['dc_liuba','dc_huangquan','furongfuqian','xianglang','dc_huojun','gaoxiang','dc_wuban','jiangfei'],
@@ -393,9 +393,9 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 						},
 						forced:true,
 						notUseOrRespond(event,player){
-							if(event.name==='cardsDiscard') return false;
+							if (event.name !== 'cardsDiscard') return true;
 							const evtx = event.getParent();
-							if(evtx.name==='orderingDiscard') return false;
+							if (evtx.name !== 'orderingDiscard') return true;
 							const evt2 = (evtx.relatedEvent || evtx.getParent());
 							return !['useCard', 'respond'].includes(evt2.name) || evt2.player !== player;
 						},
@@ -3562,46 +3562,46 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					return (get.type(card) == 'trick' || get.color(card) == 'black' && get.type(card) == 'basic') &&
 						(marked || !marked && game.hasPlayer(current => current.hasMark('dcjizhong')));
 				},
-				direct:true,
+				logTarget: event => event.targets[0],
-				content:function(){
+				prompt2(event, player) {
-					'step 0'
+					const target = event.targets[0];
-					var target=trigger.targets[0];
+					if (target.hasMark('dcjizhong')) return '获得该角色区域内的一张牌';
-					var card={name:trigger.card.name,nature:trigger.card.nature,isCard:true};
-					event.target=target;
-					event.card=card;
-					if(target.hasMark('dcjizhong')) player.gainPlayerCard(get.prompt('dcrihui',target),target,'hej').set('logSkill',['dcrihui',target]);
 					else {
-						player.chooseBool(get.prompt('dcrihui',target),'令所有有“信众”的角色依次视为对其使用一张'+get.translation(card)).set('ai',()=>{
+						const card = { name: event.card.name, nature: event.card.nature, isCard: true };
-							return _status.event.bool;
+						return '令所有有“信众”的角色依次视为对其使用一张' + get.translation(card);
-						}).set('bool',function(){
+					}
-							var eff=0;
+				},
+				check(event, player) {
+					const target = event.targets[0];
+					if (target.hasMark('dcjizhong')) {
+						return get.effect(target, { name: 'shunshou_copy' }, event, player) > 0;
+					}
+					else {
+						const card = { name: event.card.name, nature: event.card.nature, isCard: true };
+						let eff = 0;
 						game.countPlayer(current => {
-								if(!current.hasMark('dcjizhong')) return;
+							if (!current.hasMark('dcjizhong') || !current.canUse(card, player, false)) return;
 							eff += get.effect(target, card, current, player);
 						});
 						return eff > 0;
-						}());
 					}
-					'step 1'
+				},
-					if(!result.bool){
+				async content(event, trigger, player) {
-						player.storage.counttrigger.dcrihui--;
+					const target = trigger.targets[0];
-						event.finish();
+					if (target.hasMark('dcjizhong')) {
-						return;
+						await player.gainPlayerCard(target, 'hej', true)
 					}
-					if(target.hasMark('dcjizhong')) event.finish();
 					else {
-						player.logSkill('dcrihui',target);
+						const card = { name: trigger.card.name, nature: trigger.card.nature, isCard: true };
-						event.targets=game.filterPlayer(current=>current.hasMark('dcjizhong'));
+						const targets = game.filterPlayer(current => current.hasMark('dcjizhong')).sortBySeat(_status.currentPhase);
-						event.targets.sortBySeat(_status.currentPhase);
+						for (const current of targets) {
+							if (target.isIn() && current.isIn() && current.canUse(card, target, false)) {
+								await current.useCard(card, target, false);
 							}
-					'step 2'
-					var current=event.targets.shift();
-					if(current.canUse(card,target,false)){
-						current.useCard(card,target,false);
 						}
-					if(event.targets.length) event.redo();
 					}
 				},
+			},
 			dcguangshi:{
 				audio:2,
 				trigger:{player:'phaseZhunbeiBegin'},
@@ -5104,29 +5104,23 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 				audio:2,
 				trigger:{target:'useCardToTargeted'},
 				usable:2,
-				direct:true,
 				filter:function(event,player){
 					return event.player!=player&&(get.type(event.card)=='trick'||event.card.name=='sha')&&player.countCards('he')>1;
 				},
-				content:function(){
+				async cost(event, trigger, player) {
-					'step 0'
+					const str = '，若重铸的牌中没有' + get.translation(get.type2(trigger.card)) + '牌，你于' + get.translation(trigger.cards) + '进入弃牌堆后获得之';
-					var str='，若重铸的牌中没有'+get.translation(get.type2(trigger.card))+'牌，你于'+get.translation(trigger.cards)+'进入弃牌堆后获得之';
+					event.result = await player.chooseCard(get.prompt('dcqianzheng'), '重铸两张牌' + (trigger.cards.length ? str : '') + '。', 2, 'he', lib.filter.cardRecastable).set('ai', card => {
-					player.chooseCard(get.prompt('dcqianzheng'),'重铸两张牌'+(trigger.cards.length?str:'')+'。',2,'he',lib.filter.cardRecastable).set('ai',card=>{
 						var val = get.value(card);
 						if (get.type2(card) == _status.event.type) val += 0.5;
 						return 6 - val;
-					}).set('type',get.type2(trigger.card));
+					}).set('type', get.type2(trigger.card)).forResult();
-					'step 1'
+				},
-					if(result.bool){
+				async content(event, trigger, player) {
-						var cards=result.cards;
+					if (event.cards.every(card => get.type2(card) != get.type2(trigger.card))) {
-						player.logSkill('dcqianzheng');
-						player.recast(cards);
-						if(cards.every(card=>get.type2(card)!=get.type2(trigger.card))){
 						trigger.getParent().dcqianzheng = true;
 						player.addTempSkill('dcqianzheng_gain');
 					}
-					}
+					await player.recast(event.cards);
-					else player.storage.counttrigger.dcqianzheng--;
 				},
 				subSkill:{
 					gain:{
@@ -5347,7 +5341,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					'step 1'
 					var num=player.getDamagedHp();
 					if(!player.isIn()||!num) event.finish();
-					else player.chooseTarget('御关：令'+get.cnNumber(num)+'名角色将手牌摸至体力上限',Math.min(game.countPlayer(),[1,num]),true).set('ai',target=>{
+					else player.chooseTarget('御关：令至多'+get.cnNumber(num)+'名角色将手牌摸至体力上限',Math.min(game.countPlayer(),[1,num]),true).set('ai',target=>{
 						return get.attitude(_status.event.player,target)*Math.max(0.1,target.maxHp-target.countCards('h'));
 					});
 					'step 2'
@@ -6254,24 +6248,22 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					return event.player!=player&&get.color(event.card)=='black';
 				},
 				usable:2,
-				direct:true,
+				async cost(event, trigger, player) {
-				content:function(){
-					'step 0'
 					if (player.countCards('h') < player.hp) {
-						player.chooseBool(get.prompt('dcqingyan'),'将手牌摸至体力上限（摸'+get.cnNumber(player.maxHp-player.countCards('h'))+'张牌）').set('ai',()=>1);
+						event.result = await player.chooseBool(get.prompt('dcqingyan'), '将手牌摸至体力上限（摸' + get.cnNumber(player.maxHp - player.countCards('h')) + '张牌）').set('ai', () => 1).forResult();
-					}else{
-						player.chooseToDiscard(get.prompt('dcqingyan'),'弃置一张手牌令你的手牌上限+1').set('ai',card=>6-get.value(card)).set('logSkill','dcqingyan');
 					}
-					'step 1'
+					else {
-					if(result.bool){
+						event.result = await player.chooseToDiscard(get.prompt('dcqingyan'), '弃置一张手牌令你的手牌上限+1', 'chooseonly').set('ai', card => 6 - get.value(card)).forResult();
-						if(result.cards&&result.cards.length){
+					}
+				},
+				async content(event, trigger, player) {
+					if (event.cards && event.cards.length) {
+						await player.dicard(cards);
 						lib.skill.dcxieshou.change(player, 1);
 					} else {
-							player.logSkill('dcqingyan');
 						player.drawTo(player.maxHp);
 					}
-					} else player.storage.counttrigger.dcqingyan--;
+				},
-				}
 			},
 			dcqizi:{
 				mod:{
@@ -6633,8 +6625,11 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					global:['gainAfter','loseAsyncAfter'],
 				},
 				usable:1,
-				filter:function(event,player){
+				getIndex(event, player){
-					return lib.skill.dcyingtu.filterx(event,player,player.getNext())||lib.skill.dcyingtu.filterx(event,player,player.getPrevious());
+					var targets=[];
+					if(lib.skill.dcyingtu.filterx(event,player,player.getNext())) targets.add(player.getNext());
+					if(lib.skill.dcyingtu.filterx(event,player,player.getPrevious())) targets.add(player.getPrevious());
+					return targets.sortBySeat(_status.currentPhase);
 				},
 				filterx:function(event,player,target){
 					var evt=event.getParent('phaseDraw');
@@ -6643,41 +6638,18 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 						return lib.filter.canBeGained(card,target,player)
 					},'he');
 				},
-				logTarget:'player',
+				logTarget(event, player, triggername, target){
-				direct:true,
+					return target;
-				checkx:function(player,source){
+				},
+				check(event, player, triggername, source){
 					var target=(source==player.getNext()?player.getPrevious():player.getNext());
 					return Math.min(0,get.attitude(player,target))>=get.attitude(player,source);
 				},
+				prompt2:'获得该角色的一张牌，然后将一张牌交给该角色的对位角色。若你给出的是装备牌，则其使用其得到的牌。',
 				content:function(){
 					'step 0'
-					var targets=[];
+					var target=event.targets[0];
-					event.targets=targets;
-					if(lib.skill.dcyingtu.filterx(trigger,player,player.getNext())) targets.add(player.getNext());
-					if(lib.skill.dcyingtu.filterx(trigger,player,player.getPrevious())) targets.add(player.getPrevious());
-					'step 1'
-					var target=targets.shift();
 					event.target=target;
-					player.chooseBool(
-						get.prompt('dcyingtu',target),
-						'获得该角色的一张牌，然后将一张牌交给该角色的对位角色。若你给出的是装备牌，则其使用其得到的牌。'
-					).set('goon',lib.skill.dcyingtu.checkx(player,target)).set('ai',function(){
-						return _status.event.goon;
-					});
-					'step 2'
-					if(result.bool){
-						player.logSkill('dcyingtu',target);
-						var next=game.createEvent('dcyingtu_insert');
-						next.player=player;
-						next.target=target;
-						next.setContent(lib.skill.dcyingtu.contentx);
-						event.finish();
-					}
-					else if(targets.length>0) event.goto(1);
-					else player.storage.counttrigger.dcyingtu--;
-				},
-				contentx:function(){
-					'step 0'
 					event.side=(target==player.getPrevious()?'getNext':'getPrevious');
 					player.gainPlayerCard(target,true,'he');
 					'step 1'
@@ -6705,7 +6677,6 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 				audio:2,
 				trigger:{global:'useCardAfter'},
 				forced:true,
-				locked:false,
 				filter:function(event,player){
 					return get.type(event.card,null,false)=='equip'&&event.player.isMaxEquip();
 				},
@@ -6872,8 +6843,17 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					disable:{
 						charlotte:true,
 						mod:{
-							cardEnabled2:function(card){
+							cardEnabled(card, player){
-								if(get.position(card)=='h') return false;
+								if (card.cards) {
+									const hs = player.getCards('h');
+									if (card.cards.some(card => hs.includes(card))) return false;
+								}
+							},
+							cardSavable(card, player){
+								if (card.cards) {
+									const hs = player.getCards('h');
+									if (card.cards.some(card => hs.includes(card))) return false;
+								}
 							},
 						},
 						mark:true,
@@ -9537,7 +9517,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					player.chooseControl(lib.suit,'cancel2').set('prompt',get.prompt('huguan',trigger.player)).set('prompt2','令某种花色的手牌不计入其本回合的手牌上限').set('ai',function(){
 						var player=_status.event.player,target=_status.event.getTrigger().player,att=get.attitude(player,target);
 						if(att <= 0){
-							if (!player.hasSkill('yaopei') || player.hasAllHistory('useSkill',function(evt){
+							if (!player.hasSkill('yaopei') || player.hasHistory('useSkill',function(evt){
 								return evt.skill=='huguan'&&evt.targets.includes(target);
 							}) || target.needsToDiscard() - target.needsToDiscard(-target.countCards('h') / 4) > (att>-2?1.6:1)) return 'cancel2';
 						}
@@ -10284,30 +10264,28 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					if(player==event.player||event.targets.length!=1) return false;
 					return player.countCards('h')>=2;
 				},
-				direct:true,
 				usable:2,
-				content:function(){
+				async cost(event, trigger, player) {
-					'step 0'
+					event.result = await player.chooseToDiscard('he', [2, Infinity], get.prompt('reshejian', trigger.player), '<div class="text center">弃置至少两张手牌，然后选择一项：<br>⒈弃置其等量的牌。⒉对其造成1点伤害。</div>').set('ai', function (card) {
-					player.chooseToDiscard('he',[2,Infinity],get.prompt('reshejian',trigger.player),'<div class="text center">弃置至少两张手牌，然后选择一项：<br>⒈弃置其等量的牌。⒉对其造成1点伤害。</div>').set('ai',function(card){
 						if (_status.event.goon && ui.selected.cards.length < 2) return 5.6 - get.value(card);
 						return 0;
-					}).set('goon',function(){
+					}, 'chooseonly').set('goon', function () {
 						var target = trigger.player;
 						if (get.damageEffect(target, player, player) > 0) return true;
 						if (target.countCards('he', function (card) {
 							return get.value(card, target) > 6;
 						}) >= 2) return true;
 						return false;
-					}()).logSkill=['reshejian',trigger.player];
+					}()).forResult();
+				},
+				logTarget: 'player',
+				content: function () {
+					'step 0'
+					player.discard(cards);
 					'step 1'
-					if(!result.bool){
+					var num = cards.length;
-						player.storage.counttrigger.reshejian--;
-						event.finish();
-						return;
-					}
-					var num=result.cards.length;
 					event.num = num;
-					var target=trigger.player,str=get.translation(target);
+					var target = targets[0], str = get.translation(target);
 					event.target = target;
 					if (!target.isIn()) event.finish();
 					else if (!target.hasCard(function (card) {
@@ -10389,34 +10367,35 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			rewangzu:{
 				audio:2,
 				trigger:{player:'damageBegin1'},
-				direct:true,
 				filter:function(event,player){
 					return event.source&&player!=event.source&&player.hasCard((card)=>lib.filter.cardDiscardable(card,player,'rewangzu'),'h');
 				},
 				usable:1,
-				content:function(){
+				async cost(event, trigger, player) {
 					'step 0'
 					var num = player.getFriends().length;
 					if (!game.hasPlayer(function (current) {
 						return current != player && current.getFriends().length > num;
 					})) {
-						player.chooseToDiscard('h',get.prompt('rewangzu'),'弃置一张牌并令伤害-1').set('ai',function(card){
+						player.chooseToDiscard('h', get.prompt('rewangzu'), '弃置一张牌并令伤害-1', 'chooseonly').set('ai', function (card) {
 							return 7 - get.value(card);
-						}).logSkill='rewangzu';
+						});
 					}
 					else {
 						player.chooseBool(get.prompt('rewangzu'), '随机弃置一张牌并令伤害-1');
 					}
 					'step 1'
-					if(result.bool){
+					event.result = result;
+				},
+				async content(event, trigger, player) {
 					trigger.num--;
-						if(!result.cards||!result.cards.length){
+					if (!event.cards || !event.cards.length) {
-							player.logSkill('rewangzu');
+						const cards = player.getCards('h', (card) => lib.filter.cardDiscardable(card, player, 'rewangzu'));
-							var cards=player.getCards('h',(card)=>lib.filter.cardDiscardable(card,player,'rewangzu'));
 						if (cards.length) player.discard(cards.randomGet());
 					}
+					else {
+						player.discard(event.cards);
 					}
-					else player.storage.counttrigger.rewangzu--;
 				},
 			},
 			//万年公主
@@ -11231,48 +11210,41 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			spwanggui:{
 				audio:'wanggui',
 				trigger:{source:'damageSource'},
-				direct:true,
 				usable:1,
 				filter:function(event,player){
 					return game.hasPlayer(function(current){
 						return current.group!=player.group;
 					});
 				},
-				content:function(){
+				async cost(event, trigger, player){
-					'step 0'
+					event.result = await player.chooseTarget(get.prompt('spwanggui'),'对一名势力不同的其他角色造成1点伤害',function(card,player,target){
-					player.chooseTarget(get.prompt('spwanggui'),'对一名势力不同的其他角色造成1点伤害',function(card,player,target){
 						return target.group!=player.group;
 					}).set('ai',function(target){
 						var player=_status.event.player;
 						return get.damageEffect(target,player,player);
-					});
+					}).forResult();
-					'step 1'
+				},
-					if(result.bool){
+				async content(event, trigger, player){
-						var target=result.targets[0];
+					const target = event.targets[0];
-						player.logSkill('spwanggui',target);
 					target.damage();
-					}
-					else player.storage.counttrigger.spwanggui--;
 				},
 				group:'spwanggui_draw',
 				subSkill:{
 					draw:{
 						trigger:{player:'damageEnd'},
-						direct:true,
+						async cost(event, trigger, player){
-						content:function(){
+							event.result = await player.chooseTarget(get.prompt('spwanggui'),'令自己摸一张牌，或和一名势力相同的其他角色各摸一张牌',function(card,player,target){
-							'step 0'
-							player.chooseTarget(get.prompt('spwanggui'),'令自己摸一张牌，或和一名势力相同的其他角色各摸一张牌',function(card,player,target){
 								return target.group==player.group;
 							}).set('ai',function(target){
 								var player=_status.event.player,att=get.attitude(player,target);
 								if(target!=player) att*=2;
 								if(target.hasSkillTag('nogain')) att/=1.7;
 								return att;
-							});
+							}).forResult();
-							'step 1'
+						},
-							if(result.bool){
+						content:function(){
-								var target=result.targets[0];
+							'step 0'
-								player.logSkill('spwanggui',target);
+							var target=targets[0];
 							if(player==target){
 								player.draw();
 								event.finish();
@@ -11281,9 +11253,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 								var list=[player,target].sortBySeat();
 								game.asyncDraw(list);
 							}
-							}
+							'step 1'
-							else event.finish();
-							'step 2'
 							game.delayx();
 						},
 					},
@@ -12530,7 +12500,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 		translate:{
 			re_panfeng:'潘凤',
 			xinkuangfu:'狂斧',
-			xinkuangfu_info:'出牌阶段限一次，你可选择：1，弃置装备区里的一张牌，你使用无对应实体牌的普【杀】。若此【杀】造成伤害，你摸两张牌。2，弃置一名其他角色装备区里的一张牌，你使用无对应实体牌的普【杀】。若此【杀】未造成伤害，你弃置两张手牌。',
+			xinkuangfu_info:'出牌阶段限一次，你可选择：1，弃置装备区里的一张牌，你使用无对应实体牌的普【杀】。若此【杀】造成伤害，你摸两张牌。2，弃置一名其他角色装备区里的一张牌，你使用无对应实体牌的普【杀】。若此【杀】未造成伤害，你弃置两张手牌。（均无距离和次数限制）',
 			xingdaorong:'邢道荣',
 			xuxie:'虚猲',
 			xuxie_info:'出牌阶段开始时，你可以减1点体力上限并选择所有距离1以内的角色，弃置这些角色的各一张牌或令这些角色各摸一张牌。出牌阶段结束时，若你的体力上限不为全场最多，则你加1点体力上限，然后回复1点体力或摸两张牌。',
@@ -12594,7 +12564,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			huguan:'护关',
 			huguan_info:'一名角色于出牌阶段内使用第一张牌时，若此牌为红色，则你可以声明一种花色。该花色的牌不计入其本回合的手牌上限。',
 			yaopei:'摇佩',
-			yaopei_info:'其他角色的弃牌阶段结束时，若你本局游戏内对其发动过〖护关〗，则你可以弃置一张与其于此阶段弃置的牌花色均不相同的牌。然后你选择一项：①其摸两张牌，你回复1点体力。②其回复1点体力，你摸两张牌。',
+			yaopei_info:'其他角色的弃牌阶段结束时，若你本回合内对其发动过〖护关〗，则你可以弃置一张与其于此阶段弃置的牌花色均不相同的牌。然后你选择一项：①其摸两张牌，你回复1点体力。②其回复1点体力，你摸两张牌。',
 			mingluan:'鸣鸾',
 			mingluan_info:'其他角色的结束阶段开始时，若有角色于本回合内回复过体力，则你可以弃置任意张牌，然后摸X张牌（X为当前角色的手牌数，且至多摸至5张）。',
 			zhangxuan:'张嫙',
@@ -12647,8 +12617,8 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			zhtongyuan_info:'锁定技。①当你使用红色锦囊牌后，你于〖摧坚〗后增加“若其手牌中没有【闪】，则你摸两张牌”；②当你使用或打出红色基本牌后，你删除〖摧坚〗中的“，然后你交给其等量的牌”。③当你使用红色的普通锦囊牌/基本牌时，若你已发动过〖摧坚①〗和〖摧坚②〗，则此牌不可被响应/可额外增加一个目标。',
 			lvlingqi:'吕玲绮',
 			guowu:'帼舞',
-			guowu_info:'出牌阶段开始时，你可以展示全部手牌，根据你展示的类型数，你获得对应效果：至少一类，从弃牌堆获得一张【杀】；至少两类，此阶段使用牌无距离限制；至少三类，此阶段使用【杀】或普通锦囊牌可以多指定两个目标。',
+			guowu_info:'出牌阶段开始时，你可以展示全部手牌，根据你展示的类型数，你获得对应效果：至少一类，从弃牌堆获得一张【杀】；至少两类，此阶段使用牌无距离限制；至少三类，此阶段使用【杀】或普通锦囊牌可以多指定至多两个目标。',
-			guowu_info_guozhan:'出牌阶段开始时，你可以展示全部手牌，根据你展示的类型数，你获得对应效果：至少一类，从弃牌堆获得一张【杀】；至少两类，此阶段使用牌无距离限制；至少三类，此阶段使用【杀】可以多指定两个目标。',
+			guowu_info_guozhan:'出牌阶段开始时，你可以展示全部手牌，根据你展示的类型数，你获得对应效果：至少一类，从弃牌堆获得一张【杀】；至少两类，此阶段使用牌无距离限制；至少三类，此阶段使用【杀】可以多指定至多两个目标。',
 			zhuangrong:'妆戎',
 			zhuangrong_info:'觉醒技，一名角色的回合结束时，若你的体力值或手牌数为1，你减1点体力上限并回复体力至上限，将手牌摸至体力上限，然后获得〖神威〗和〖无双〗。',
 			llqshenwei:'神威',
@@ -12666,10 +12636,10 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			refenglve:'锋略',
 			refenglve_info:'出牌阶段限一次，你可以和一名其他角色进行拼点。若你赢，其将区域内的两张牌交给你；若平局，则你令此技能于本阶段内的发动次数上限+1；若你输，其获得你的拼点牌。',
 			anyong:'暗涌',
-			anyong_info:'当一名角色于其回合内第一次对其他角色造成伤害后，若伤害值为1，则你可弃置一张牌，并对受伤角色造成1点伤害。',
+			anyong_info:'当一名角色于其回合内第一次对另一名其他角色造成伤害后，若伤害值为1，则你可弃置一张牌，并对受伤角色造成1点伤害。',
 			wanniangongzhu:'万年公主',
 			zhenge:'枕戈',
-			zhenge_info:'准备阶段，你可以选择一名角色。该角色本局游戏的攻击范围+1（至多+5）。然后若所有其他角色都在该角色的攻击范围内，则你可以令其视为对另一名角色使用一张【杀】。',
+			zhenge_info:'准备阶段，你可以选择一名角色。该角色本局游戏的攻击范围+1（至多+5）。然后若除其外的所有角色都在该角色的攻击范围内，则你可以令其视为对另一名角色使用一张【杀】。',
 			xinghan:'兴汉',
 			xinghan_info:'锁定技，每回合的第一张【杀】造成伤害后，若此【杀】的使用者成为过〖枕戈〗的目标，则你摸一张牌。若你的手牌数不是全场唯一最多的，则改为摸X张牌（X为该角色的攻击范围且最多为5）。',
 			re_chendeng:'陈登',
@@ -12682,8 +12652,8 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			re_miheng:'祢衡',
 			rekuangcai:'狂才',
 			rekuangcai_info:'锁定技。①你于回合内使用牌无距离和次数限制。②弃牌阶段开始时，若你本回合内：未使用过牌，则你本局游戏的手牌上限+1；使用过牌但未造成过伤害，则你本局游戏的手牌上限-1。③结束阶段开始时，你摸X张牌（X为你本回合内造成的伤害且至多为5）。',
-			reshejian:'舌箭',
+			reshejian:'舌剑',
-			reshejian_info:'当你成为其他角色使用牌的唯一目标后，你可以弃置至少两张手牌。若如此做，你选择一项：⒈弃置其等量的牌。⒉对其造成1点伤害。',
+			reshejian_info:'每回合限两次。当你成为其他角色使用牌的唯一目标后，你可以弃置至少两张手牌。若如此做，你选择一项：⒈弃置其等量的牌。⒉对其造成1点伤害。',
 			fengxi:'冯熙',
 			yusui:'玉碎',
 			yusui_info:'当你成为其他角色使用黑色牌的目标后，你可以失去1点体力，然后选择一项：⒈令其将手牌数弃置至与你相同；⒉令其失去Y点体力（Y为其的体力值减去你的体力值，不为正时不可选择）。',
@@ -12700,7 +12670,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			zhengding:'正订',
 			zhengding_info:'锁定技。当你于回合外使用或打出牌响应其他角色使用的牌时，若这两张牌颜色相同，则你加1点体力上限并回复1点体力。',
 			dc_jiben:'吉本',
-			xunli:'寻疠',
+			xunli:'询疠',
 			xunli_info:'锁定技。①当有黑色牌因弃置而进入弃牌堆后，若X大于0，则你将其中的X张牌置于武将牌上作为“疠”（X=min(这些牌的数量，9-Y)，Y=你的“疠”数）。②出牌阶段开始时，你可以用任意张黑色手牌交换等量的“疠”。',
 			zhishi:'指誓',
 			zhishi_info:'结束阶段，你可选择一名角色。当该角色于你的下回合开始前{成为【杀】的目标后或进入濒死状态时}，你可移去任意张“疠”，然后其摸等量的牌。',
@@ -12768,14 +12738,14 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			dcyongbi_info:'限定技。出牌阶段，你可以将所有手牌交给一名其他男性角色。你将〖媵予〗的发动时机改为“准备阶段和结束阶段开始时”。然后若这些牌中包含的花色数：大于1，则你与其本局游戏的手牌上限+2；大于2，则当你或其于本局游戏内受到大于1的伤害时，此伤害-1。',
 			dc_huangquan:'黄权',
 			dcquanjian:'劝谏',
-			dcquanjian_info:'出牌阶段每项各限一次。你可以选择一项流程并选择一名其他角色A：⒈令A对其攻击范围内的另一名角色B造成1点伤害。⒉令A将手牌数调整至手牌上限（至多摸至五张），且其本回合内不能使用或打出手牌。然后A选择一项：⒈执行此流程。⒉本回合下次受到的伤害+1。',
+			dcquanjian_info:'出牌阶段每项各限一次。你可以选择一项流程并选择一名其他角色A：⒈令A对其攻击范围内的另一名角色B造成1点伤害。⒉令A将手牌数调整至手牌上限（至多摸至五张），且其本回合内不能使用手牌。然后A选择一项：⒈执行此流程。⒉本回合下次受到的伤害+1。',
 			dctujue:'途绝',
 			dctujue_info:'限定技。当你进入濒死状态时，你可以将所有牌交给一名其他角色。然后你回复等量的体力并摸等量的牌。',
 			chengui:'陈珪',
 			dcyingtu:'营图',
 			dcyingtu_info:'每回合限一次。当你的上家/下家于摸牌阶段外得到牌后，你可以获得其一张牌，然后将一张牌交给你的下家/上家。若你给出的牌为装备牌，则其使用之。',
 			dccongshi:'从势',
-			dccongshi_info:'一名角色使用的装备牌结算结束后，若其装备区内的牌数为全场最多，则你摸一张牌。',
+			dccongshi_info:'锁定技。一名角色使用的装备牌结算结束后，若其装备区内的牌数为全场最多，则你摸一张牌。',
 			wanglie:'王烈',
 			dcchongwang:'崇望',
 			dcchongwang_info:'其他角色使用基本牌或普通锦囊牌时，若你是本局游戏内上一张被使用的牌的使用者，则你可以选择一项：⒈令其于此牌结算结束后收回此牌对应的所有实体牌；⒉取消此牌的所有目标。',

character/mobile.js

@@ -6,7 +6,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 		connect:true,
 		characterSort:{
 			mobile:{
-				mobile_default:['xin_huojun','muludawang','mb_chengui','mb_huban','mb_xianglang','yanxiang','xin_wuban','laimin','baoxin','jiangji','liwei','xin_guozhao',"miheng","taoqian","lingcao","sunru","lifeng","zhuling","liuye","zhaotongzhaoguang","majun","simazhao","wangyuanji","pangdegong","shenpei","hujinding","zhangyì","jiakui","yangbiao","chendeng","dongcheng","yangyi","dengzhi","zhengxuan","sp_sufei","furong","dingyuan","simashi","yanghuiyu","hucheer","gongsunkang","nanhualaoxian","zhouqun","qiaozhou","fuqian","simafu","mayuanyi","yanpu","sunhanhua","sp_maojie","peixiu","sp_jianggan","ruanhui","xin_mamidi","sp_caosong","yangfu","wangjun","sp_pengyang","qianzhao",'shichangshi','yangfeng'],
+				mobile_default:['mb_sp_guanqiujian','mb_caomao','chengji','lizhaojiaobo','xin_huojun','muludawang','mb_chengui','mb_huban','mb_xianglang','yanxiang','xin_wuban','laimin','baoxin','jiangji','liwei','xin_guozhao',"miheng","taoqian","lingcao","sunru","lifeng","zhuling","liuye","zhaotongzhaoguang","majun","simazhao","wangyuanji","pangdegong","shenpei","hujinding","zhangyì","jiakui","yangbiao","chendeng","dongcheng","yangyi","dengzhi","zhengxuan","sp_sufei","furong","dingyuan","simashi","yanghuiyu","hucheer","gongsunkang","nanhualaoxian","zhouqun","qiaozhou","fuqian","simafu","mayuanyi","yanpu","sunhanhua","sp_maojie","peixiu","sp_jianggan","ruanhui","xin_mamidi","sp_caosong","yangfu","wangjun","sp_pengyang","qianzhao",'shichangshi','yangfeng'],
 				mobile_yijiang:["yj_zhanghe","yj_zhangliao","yj_xuhuang","yj_ganning",'yj_huangzhong','yj_weiyan','yj_zhoubuyi'],
 				mobile_standard:["xin_xiahoudun","xin_zhangfei"],
 				mobile_shenhua_feng:['re_xiaoqiao',"xin_zhoutai"],
@@ -26,6 +26,10 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			},
 		},
 		character:{
+			mb_sp_guanqiujian:['male','wei',4,['mbcuizhen','mbkuili']],
+			mb_caomao:['male','wei',3,['mbqianlong','mbweitong'],['zhu']],
+			chengji:['male','wei',4,['mbkuangli','mbxiongsi']],
+			lizhaojiaobo:['male','wei',4,['mbzuoyou','mbshishou']],
 			yangfeng:['male','qun',4,['mbxuetu','mbweiming']],
 			xin_huojun:['male','shu',4,['sidai','jieyu'],['character:tw_huojun','die_audio:tw_huojun']],
 			muludawang:['male','qun','3/3/1',['shoufa','zhoulin','yuxiang']],
@@ -179,6 +183,8 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			scs_gaowang:['male','qun','',['scsmiaoyu'],['unseen','sex:male_castrated']],
 		},
 		characterIntro:{
+			lizhaojiaobo:'李昭（？—约公元260年），三国时期曹魏官吏，官拜冗从仆射，为魏帝曹髦的亲信。<br>焦伯，三国时期人物，魏帝曹髦护卫，官拜黄门从官。<br>曹髦见自己权力威势日渐削弱，感到不胜忿恨，于公元260年（甘露五年）五月初六夜里，令李昭和焦伯等在陵云台布署甲士，出讨司马昭，但最终失败，曹髦为成济所弑，李昭和焦伯等应该也战死。在《三国演义》里，焦伯挺枪出战成济，亦被成济所杀。',
+			chengji:'成济（？～260年6月21日），三国时期曹魏官员。官至太子舍人。在魏帝曹髦起兵讨司马昭时，受到司马昭之心腹贾充指使，刺死曹髦。司马昭为平息众怒，将成倅、成济兄弟二人杀死。',
 			yangfeng:'杨奉（？－197年/198年），东汉末年将领。杨奉早年参加白波军起义，曾经帮助李傕对抗郭汜，后来背叛李傕。兴平二年，加号兴义将军，护送汉献帝刘协东归雒阳，颇有功勋，加号车骑将军，屯兵于梁县。建安元年，随着汉献帝迁都许县，失去权力，先后依附于袁术、吕布，劫掠徐州和扬州地区。建安二年（一说三年），带兵进犯刘备领地，被刘备诱杀。',
 			muludawang:'古典小说《三国演义》中的虚构人物，八纳洞主，孟获盟友。擅驱兽法，能行风雨，控制猛兽并指挥它们作战。在法术帮助下最初对蜀军取得一些胜利，但在诸葛亮的喷火木兽将他的动物吓跑后战败，最后死于乱军之中。',
 			laimin:'来敏（165年—261年），字敬达，义阳新野人，东汉太中大夫来歙之后，司空来艳之子，三国时期蜀汉官员。东汉末年，逢董卓之乱，来敏跟随姐夫黄琬到荆州避难，黄琬是刘璋祖母的侄子，来敏又与姐姐来氏入蜀，被刘璋引为宾客。来敏喜欢读书，尤其喜欢《左氏春秋》。刘备平定益州后，以来敏为典学校尉，后立太子，来敏为家令。刘禅继位后，任命来敏为虎贲中郎将，诸葛亮驻汉中，请来敏为军祭酒、辅军将军。却因其口出狂言而被罢官，诸葛亮死后，来敏历任大长秋、光禄大夫、执慎将军等职，期间多次因说错话而被免官，蜀汉景耀年间，来敏去世，时年九十七岁。',
@@ -396,6 +402,734 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			},
 		},
 		skill:{
+			//李昭焦伯
+			mbzuoyou:{
+				audio:2,
+				enable:'phaseUse',
+				usable:1,
+				zhuanhuanji:true,
+				filterTarget(card,player,target){
+					if(player.storage.mbzuoyou) return target.countCards('h');
+					return true;
+				},
+				async content(event,trigger,player){
+					const storage = player.storage.mbzuoyou, target = event.target;
+					if (event.name === 'mbzuoyou') player.changeZhuanhuanji('mbzuoyou');
+					if (!storage) {
+						await target.draw(3);
+						await target.chooseToDiscard(2,true,'he');
+					}
+					else {
+						await target.chooseToDiscard(target===player ? '佐佑' : `${get.translation(player)}对你发动了【佐佑】`, '请弃置一张手牌，然后获得1点护甲', true);
+						await target.changeHujia(1, null, true);
+					}
+				},
+				mark:true,
+				marktext:'☯',
+				intro:{
+					content(storage,player){
+						if(!storage) return '转换技。出牌阶段限一次，你可以令一名角色摸三张牌，然后其弃置两张牌。';
+						return '转换技。出牌阶段限一次，你可以令一名角色弃置一张手牌，然后其获得1点护甲。';
+					}
+				},
+				ai:{
+					order(item,player){
+						if(player.storage.mbzuoyou&&game.hasPlayer(current=>{
+							return current!==player&&get.effect(current,'mbzuoyou',player,player)>0;
+						})) return get.order({name:'zengbin'})+0.1;
+						return 2;
+					},
+					result:{
+						target(player,target){
+							let eff=0;
+							if(player.storage.mbzuoyou) eff=target.hujia<5?1:0;
+							else eff=1;
+							if(target===player&&player.hasSkill('mbshishou')) eff/=10;
+							return eff;
+						},
+					}
+				},
+			},
+			mbshishou:{
+				audio:2,
+				forced:true,
+				trigger:{player:'useSkillAfter'},
+				filter(event,player){
+					return event.skill==='mbzuoyou'&&!event.targets.includes(player);
+				},
+				forced:true,
+				async content(event,trigger,player){
+					await lib.skill.mbzuoyou.content({
+						target: player,
+					}, {}, player);
+				},
+			},
+			//成济
+			mbkuangli:{
+				audio:2,
+				trigger:{player:'phaseUseBegin'},
+				filter(event,player){
+					return game.hasPlayer(current=>current!==player);
+				},
+				forced:true,
+				group:['mbkuangli_target','mbkuangli_remove'],
+				async content(event,trigger,player){
+					let targets = game.filterPlayer(current => current !== player).randomSort();
+					targets = targets.slice(0, Math.ceil(Math.random() * targets.length));
+					targets.sortBySeat();
+					player.line(targets, 'thunder');
+					targets.forEach(current => {
+						current.addSkill('mbkuangli_mark');
+					});
+					await game.asyncDelayx();
+				},
+				subSkill:{
+					target:{
+						audio:'mbkuangli',
+						trigger:{player:'useCardToPlayered'},
+						filter(event,player){
+							return event.target.hasSkill('mbkuangli_mark')&&[player,event.target].some(current=>current.countCards('he'));
+						},
+						forced:true,
+						logTarget:'target',
+						usable:2,
+						async content(event,trigger,player){
+							const target = trigger.target;
+							const playerCards = player.getCards('he', card => {
+								return lib.filter.cardDiscardable(card, player, 'mbkuangli');
+							});
+							if(playerCards.length>0) await player.discard(playerCards.randomGet());
+							const targetCards = target.getCards('he', card => {
+								return lib.filter.cardDiscardable(card, target, 'mbkuangli');
+							});
+							if(targetCards.length>0) await target.discard(targetCards.randomGet());
+							await game.asyncDelayx();
+							await player.draw();
+							await game.asyncDelayx();
+						},
+						ai:{
+							effect:{
+								player(card,player,target,current){
+									if(!target) return;
+									const counttrigger=player.storage.counttrigger;
+									if(counttrigger&&counttrigger.mbkuangli_target&&counttrigger.mbkuangli_target>=lib.skill.mbkuangli_target.usable) return;
+									if(target.hasSkill('mbkuangli_mark')){
+										if(get.attitude(player,target)>0) return 0.75;
+										return 1.25;
+									}
+								}
+							}
+						},
+					},
+					remove:{
+						audio:'mbkuangli',
+						trigger:{player:'phaseEnd'},
+						filter(event,player){
+							return game.hasPlayer(current=>current.hasSkill('mbkuangli_mark'));
+						},
+						forced:true,
+						async content(event,trigger,player){
+							game.countPlayer(current=>{
+								if(current.hasSkill('mbkuangli_mark')){
+									player.line(current);
+									current.removeSkill('mbkuangli_mark');
+								}
+							});
+						},
+					},
+					mark:{
+						mark:true,
+						marktext:'戾',
+						charlotte:true,
+						intro:{
+							name:'狂戾',
+							name2:'狂戾',
+							content:'已拥有“狂戾”标记',
+						}
+					},
+				},
+			},
+			mbxiongsi:{
+				audio:2,
+				enable:'phaseUse',
+				filter(event,player){
+					return player.countCards('h')>=3;
+				},
+				limited:true,
+				skillAnimation:true,
+				animationColor:'fire',
+				filterCard:true,
+				selectCard:[-1,-2],
+				async content(event,trigger,player){
+					player.awakenSkill('mbxiongsi');
+					const targets = game.filterPlayer(current => current !== player);
+					for (const target of targets) {
+						player.line(target, 'thunder');
+						await target.loseHp();
+					}
+				},
+				ai:{
+					order(item,player){
+						if(get.effect(player,'mbxiongsi',player)<=0) return 1;
+						if(player.countCards('h')>3&&player.countCards('h',card=>{
+							return player.hasValueTarget(card);
+						})>0) return 0.1;
+						return 8;
+					},
+					result:{
+						player(player){
+							let eff=0;
+							game.countPlayer(current=>{
+								let effx=get.effect(current,{name:'losehp'},player,player);
+								if(get.attitude(player,current)<-6&&current.getHp()<=1) effx*=1.3;
+								eff+=effx;
+							});
+							eff*=player.getHp()+player.countCards('hs',card=>player.canSaveCard(card,player))<=2?1.5:0.35;
+							eff-=player.getCards('h').map(card=>{
+								if(lib.filter.cardDiscardable(card,player,'mbxiongsi')) return get.value(card);
+								return 0;
+							}).reduce((p,c)=>p+c,0);
+							if(eff>0) return 2;
+							return -1;
+						},
+					},
+				},
+			},
+			//SP母兵脸
+			mbcuizhen:{
+				trigger:{
+					global:'phaseBefore',
+					player:'enterGame',
+				},
+				filter(event,player){
+					return (event.name!='phase'||game.phaseNumber==0)&&game.hasPlayer(current=>{
+						return current!==player&&current.hasEnabledSlot(1);
+					});
+				},
+				async cost(event,trigger,player){
+					event.result = await player.chooseTarget(get.prompt('mbcuizhen'), '废除至多两名其他角色的武器栏', [1, 2], (card, player, target) => {
+						return target !== player && target.hasEnabledSlot(1);
+					}).set('ai', target => {
+						return -get.attitude(get.player(), target);
+					}).forResult();
+				},
+				group:['mbcuizhen_inphase','mbcuizhen_draw'],
+				async content(event,trigger,player){
+					const targets = event.targets.slice().sortBySeat();
+					for (const target of targets) {
+						await target.disableEquip(1);
+					}
+					await game.asyncDelay();
+				},
+				subSkill:{
+					inphase:{
+						audio:'mbcuizhen',
+						trigger:{
+							player:'useCardToPlayered',
+						},
+						filter(event,player){
+							if(!player.isPhaseUsing()) return false;
+							if(!get.tag(event.card,'damage')) return false;
+							const target=event.target;
+							return target!==player&&target.countCards('h')>=target.getHp()&&target.hasEnabledSlot(1);
+						},
+						prompt2:'废除其的武器栏',
+						logTarget:'target',
+						check(event,player){
+							return get.attitude(player,event.target)<=0;
+						},
+						async content(event,trigger,player){
+							await trigger.target.disableEquip(1);
+							await game.asyncDelayx();
+						},
+					},
+					draw:{
+						audio:'mbcuizhen',
+						trigger:{player:'phaseDrawBegin2'},
+						forced:true,
+						locked:false,
+						filter(event,player){
+							return !event.numFixed&&game.hasPlayer(current=>{
+								return current.hasDisabledSlot(1);
+							});
+						},
+						async content(event,trigger,player){
+							trigger.num += Math.min(2, game.countPlayer(current => {
+								return current.countDisabledSlot(1);
+							}));
+						},
+					},
+				},
+			},
+			mbkuili:{
+				audio:2,
+				trigger:{
+					player:'damageEnd',
+				},
+				filter(event,player){
+					return player.countCards('h')>0||event.source&&event.source.isIn()&&event.source.hasDisabledSlot(1);
+				},
+				forced:true,
+				async content(event,trigger,player){
+					if (player.countCards('h') > 0) {
+						await player.chooseToDiscard(`溃离：请弃置${get.cnNumber(trigger.num)}张手牌`, trigger.num, true);
+					}
+					const source = trigger.source;
+					if (source && source.isIn() && source.hasDisabledSlot(1)) {
+						player.line(source, 'green');
+						await source.enableEquip(1, player);
+					}
+				},
+				ai:{
+					neg:true,
+				}
+			},
+			//曹髦　史?!
+			mbqianlong:{
+				audio:6,
+				trigger:{
+					player:['mbqianlong_beginAfter','mbqianlong_addAfter','mbweitongAfter'],
+				},
+				filter(event,player){
+					let skills=[];
+					if(player.additionalSkills&&player.additionalSkills.mbqianlong) skills.addArray(player.additionalSkills.mbqianlong);
+					return player.countMark('mbqianlong')>=25*skills.length;
+				},
+				forced:true,
+				locked:false,
+				beginMarkCount:20,
+				maxMarkCount:100,
+				derivation:['mbcmqingzheng','mbcmjiushi','mbcmfangzhu','mbjuejin'],
+				addMark(player,num){
+					num = Math.min(num, lib.skill.mbqianlong.maxMarkCount - player.countMark('mbqianlong'));
+					player.addMark('mbqianlong', num);
+				},
+				group:['mbqianlong_begin','mbqianlong_add'],
+				async content(event,trigger,player){
+					player.addAdditionalSkill('mbqianlong', lib.skill.mbqianlong.derivation.slice(0, Math.floor(player.countMark('mbqianlong') / 25)));
+				},
+				marktext:'道',
+				intro:{
+					name:'道心(潜龙)',
+					name2:'道心',
+					content:'当前道心数为#',
+				},
+				subSkill:{
+					begin:{
+						audio:'mbqianlong',
+						trigger:{
+							global:'phaseBefore',
+							player:'enterGame',
+						},
+						filter(event,player){
+							return (event.name!='phase'||game.phaseNumber==0);
+						},
+						forced:true,
+						locked:false,
+						async content(event,trigger,player){
+							lib.skill.mbqianlong.addMark(player, lib.skill.mbqianlong.beginMarkCount);
+						},
+					},
+					add:{
+						audio:'mbqianlong',
+						trigger:{
+							player:['gainAfter','damageEnd'],
+							source:'damageSource',
+							global:'loseAsyncAfter',
+						},
+						filter(event,player){
+							if(player.countMark('mbqianlong')>=lib.skill.mbqianlong.maxMarkCount) return false;
+							if(event.name==='damage') return event.num>0;
+							return event.getg(player).length>0;
+						},
+						getIndex(event,player,triggername){
+							if(event.name==='damage') return event.num;
+							return 1;
+						},
+						forced:true,
+						locked:false,
+						async content(event,trigger,player){
+							let toAdd = 5 * (1 + (trigger.name === 'damage') + (event.triggername === 'damageSource'));
+							lib.skill.mbqianlong.addMark(player, toAdd);
+						},
+					},
+				},
+			},
+			mbweitong:{
+				audio:1,
+				trigger:{
+					global:'phaseBefore',
+					player:'enterGame',
+				},
+				filter(event,player){
+					return (event.name!='phase'||game.phaseNumber==0)&&game.hasPlayer(current=>{
+						return current!==player&&current.group==='wei'&&player.hasZhuSkill('mbweitong',current);
+					});
+				},
+				zhuSkill:true,
+				forced:true,
+				locked:false,
+				async content(event,trigger,player){
+					lib.skill.mbqianlong.addMark(player, 20 * game.countPlayer(current => {
+						return current !== player && current.group === 'wei' && player.hasZhuSkill('mbweitong', current);
+					}));
+				},
+			},
+			mbcmqingzheng:{
+				audio:'sbqingzheng',
+				audioname:['mb_caomao'],
+				trigger:{player:'phaseUseBegin'},
+				filter(event,player){
+					return player.countCards('h')>0;
+				},
+				direct:true,
+				content(){
+					'step 0'
+					var num=2;
+					var prompt='###'+get.prompt('sbqingzheng')+'###弃置'+get.cnNumber(num)+'种花色的所有牌';
+					var next=player.chooseButton([prompt,[lib.suit.map(i=>['','','lukai_'+i]),'vcard']],num);
+					next.set('filterButton',button=>{
+						var player=_status.event.player;
+						var cards=player.getCards('h',{suit:button.link[2].slice(6)});
+						return cards.length>0&&cards.filter(card=>lib.filter.cardDiscardable(card,player,'sbqingzheng')).length==cards.length;
+					});
+					next.set('ai',button=>{
+						var player=_status.event.player;
+						return 15-player.getCards('h',{suit:button.link[2].slice(6)}).map(i=>get.value(i)).reduce((p,c)=>p+c,0);
+					});
+					next.set('custom',{
+						replace:{
+							button:function(button){
+								if(!_status.event.isMine()) return;
+								if(button.classList.contains('selectable')==false) return;
+								var cards=_status.event.player.getCards('h',{suit:button.link[2].slice(6)});
+								if(cards.length){
+									var chosen=cards.filter(i=>ui.selected.cards.includes(i)).length==cards.length;
+									if(chosen){
+										ui.selected.cards.removeArray(cards);
+										cards.forEach(card=>{
+											card.classList.remove('selected');
+											card.updateTransform(false);
+										});
+									}else{
+										ui.selected.cards.addArray(cards);
+										cards.forEach(card=>{
+											card.classList.add('selected');
+											card.updateTransform(true);
+										});
+									}
+								}
+								if(button.classList.contains('selected')){
+									ui.selected.buttons.remove(button);
+									button.classList.remove('selected');
+									if(_status.multitarget||_status.event.complexSelect){
+										game.uncheck();
+										game.check();
+									}
+								}
+								else{
+									button.classList.add('selected');
+									ui.selected.buttons.add(button);
+								}
+								var custom=_status.event.custom;
+								if(custom&&custom.add&&custom.add.button){
+									custom.add.button();
+								}
+								game.check();
+							}
+						},
+						add:next.custom.add
+					});
+					'step 1'
+					if(result.bool){
+						var cards=result.cards;
+						if(!cards.length){
+							var suits=result.links.map(i=>i[2].slice(6));
+							cards=player.getCards('h',card=>suits.includes(get.suit(card,player)));
+						}
+						event.cards=cards;
+						if(!cards.length) event.finish();
+						else player.chooseTarget('清正：观看一名其他角色的手牌并弃置其中一种花色的所有牌',(card,player,target)=>{
+							return target!=player&&target.countCards('h');
+						}).set('ai',target=>{
+							var player=_status.event.player,att=get.attitude(player,target);
+							if(att>=0) return 0;
+							return 1-att/2+Math.sqrt(target.countCards('h'));
+						});
+					} else event.finish();
+					'step 2'
+					if(result.bool){
+						var target=result.targets[0];
+						event.target=target;
+						player.logSkill('sbqingzheng',target);
+						player.discard(cards);
+						var list=[];
+						var dialog=['清正：弃置'+get.translation(target)+'一种花色的所有牌'];
+						for(var suit of lib.suit.concat('none')){
+							if(target.countCards('h',{suit:suit})){
+								dialog.push('<div class="text center">'+get.translation(suit+'2')+'牌</div>');
+								dialog.push(target.getCards('h',{suit:suit}));
+								list.push(suit);
+							}
+						}
+						if(list.length){
+							player.chooseControl(list).set('dialog',dialog).set('ai',()=>{
+								return _status.event.control;
+							}).set('control',(()=>{
+								var getv=(cards)=>cards.map(i=>get.value(i)).reduce((p,c)=>p+c,0);
+								return list.sort((a,b)=>{
+									return getv(target.getCards('h',{suit:b}))-getv(target.getCards('h',{suit:a}));
+								})[0];
+							})());
+						}
+					} else event.finish();
+					'step 3'
+					var cards2=target.getCards('h',{suit:result.control});
+					event.cards2=cards2;
+					target.discard(cards2,'notBySelf').set('discarder',player);
+					'step 4'
+					if(event.cards2.length<cards.length) target.damage();
+				},
+			},
+			mbcmjiushi:{
+				audio:'rejiushi',
+				inherit:'rejiushi',
+				group:['rejiushi1','mbcmjiushi_check','mbcmjiushi_turnback','mbcmjiushi_gain'],
+				subSkill:{
+					check:{
+						trigger:{player:'damageBegin3'},
+						silent:true,
+						firstDo:true,
+						filter(event,player){
+							return player.isTurnedOver();
+						},
+						content(){
+							trigger.mbcmjiushi = true;
+						}
+					},
+					turnback:{
+						audio:'rejiushi',
+						audioname:['mb_caomao'],
+						trigger:{player:'damageEnd'},
+						check(event,player){
+							return player.isTurnedOver();
+						},
+						filter(event,player){
+							return event.mbcmjiushi;
+						},
+						prompt(event,player){
+							return '是否发动【酒诗】，将武将牌翻面？';
+						},
+						content(){
+							delete trigger.mbcmjiushi;
+							player.turnOver();
+						}
+					},
+					gain:{
+						audio:'rejiushi',
+						audioname:['mb_caomao'],
+						trigger:{player:'turnOverAfter'},
+						frequent:true,
+						prompt:'是否发动【酒诗】，获得牌堆中的一张锦囊牌？',
+						content(){
+							var card=get.cardPile2(function(card){
+								return get.type2(card)=='trick';
+							});
+							if(card) player.gain(card,'gain2');
+						},
+					},
+				},
+			},
+			mbcmfangzhu:{
+				audio:'sbfangzhu',
+				audioname:['mb_caomao'],
+				inherit:'sbfangzhu',
+				filter(event,player){
+					return game.hasPlayer(current=>current!==player);
+				},
+				usable:1,
+				chooseButton:{
+					dialog(){
+						const dialog=ui.create.dialog('放逐：令一名其他角色...','hidden');
+						dialog.add([[
+							[1,'不能使用手牌中的非锦囊牌直到其回合结束'],
+							[2,'非Charlotte技能失效直到其回合结束'],
+						],'textbutton']);
+						return dialog;
+					},
+					check(button){
+						const player=get.player();
+						if(button.link===2){
+							if(game.hasPlayer(target=>{
+								if(target.hasSkill('mbcmfangzhu_ban')||target.hasSkill('fengyin')||target.hasSkill('baiban')) return false;
+								return get.attitude(player,target)<0&&['name','name1','name2'].map((sum,name)=>{
+									if(target[name]&&(name!='name1'||target.name!=target.name1)){
+										if(get.character(target[name])) return get.rank(target[name],true);
+									}
+									return 0;
+								}).reduce((p,c)=>{
+									return p+c;
+								},0)>5;
+							})) return 6;
+						}
+						return button.link===1?1:0;
+					},
+					backup(links,player){
+						return {
+							num:links[0],
+							audio:'sbfangzhu',
+							filterCard:()=>false,
+							selectCard:-1,
+							filterTarget(card,player,target){
+								if(target==player) return false;
+								const num=lib.skill.mbcmfangzhu_backup.num,storage=target.getStorage('mbcmfangzhu_ban');
+								return num!=1||!storage.length;
+							},
+							async content(event,trigger,player){
+								const target=event.target;
+								const num=lib.skill.mbcmfangzhu_backup.num;
+								switch(num){
+									case 1:
+										target.addTempSkill('mbcmfangzhu_ban',{player:'phaseEnd'});
+										target.markAuto('mbcmfangzhu_ban',['trick']);
+										break;
+									case 2:
+										target.addTempSkill('mbcmfangzhu_baiban',{player:'phaseEnd'});
+										break;
+								}
+							},
+							ai:{
+								result:{
+									target(player,target){
+										switch(lib.skill.mbcmfangzhu_backup.num){
+											case 1:
+												return -target.countCards('h',card=>get.type(card)!='trick')-1;
+											case 2:
+												return -target.getSkills(null,null,false).reduce((sum,skill)=>{
+													return sum+Math.max(get.skillRank(skill,'out'),get.skillRank(skill,'in'));
+												},0);
+										}
+									},
+								},
+							},
+						}
+					},
+					prompt(links,player){
+						const str='###放逐###';
+						switch(links[0]){
+							case 1:
+								return str+'令一名其他角色不能使用手牌中的非锦囊牌直到其回合结束';
+							case 2:
+								return str+'令一名其他角色的非Charlotte技能失效直到其回合结束';
+						}
+					}
+				},
+				ai:{
+					order:10,
+					result:{
+						player(player){
+							return game.hasPlayer(current=>get.attitude(player,current)<0)?1:0;
+						},
+					},
+				},
+				subSkill:{
+					backup:{},
+					baiban:{
+						inherit:'baiban',
+						marktext:'逐',
+					},
+					ban:{
+						charlotte:true,
+						onremove:true,
+						mark:true,
+						marktext:'禁',
+						intro:{
+							markcount:()=>0,
+							content(storage){
+								if(storage.length>1) return '不能使用手牌';
+								return '不能使用手牌中的非'+get.translation(storage[0])+'牌';
+							},
+						},
+						mod:{
+							cardEnabled(card,player){
+								const storage=player.getStorage('mbcmfangzhu_ban');
+								const hs=player.getCards('h'),cards=[card];
+								if(Array.isArray(card.cards)) cards.addArray(card.cards);
+								if(cards.containsSome(...hs)&&!storage.includes(get.type2(card))) return false;
+							},
+							cardSavable(card,player){
+								const storage=player.getStorage('mbcmfangzhu_ban');
+								const hs=player.getCards('h'),cards=[card];
+								if(Array.isArray(card.cards)) cards.addArray(card.cards);
+								if(cards.containsSome(...hs)&&!storage.includes(get.type2(card))) return false;
+							},
+						},
+					},
+				},
+			},
+			mbjuejin:{
+				audio:2,
+				enable:'phaseUse',
+				limited:true,
+				skillAnimation:true,
+				animationColor:'thunder',
+				filterCard:()=>false,
+				selectCard:[-1,-2],
+				filterTarget:true,
+				selectTarget:-1,
+				multiline:true,
+				async contentBefore(event,trigger,player){
+					player.awakenSkill('mbjuejin');
+				},
+				async content(event,trigger,player){
+					const target = event.target;
+					const delt = target.getHp(true) - 1, num = Math.abs(delt);
+					await target[delt > 0 ? 'loseHp' : 'recover'](num);
+					if (num > 0) await target.changeHujia(num, null ,true);
+				},
+				async contentAfter(event,trigger,player){
+					game.addGlobalSkill('mbjuejin_xiangsicunwei');
+					player.$fullscreenpop('向死存魏！', 'thunder');
+				},
+				ai:{
+					order:0.1,
+					result:{
+						player(player){
+							let eff=1;
+							game.countPlayer(current=>{
+								const att=get.attitude(player,current),num=Math.abs(current.getHp(true)-1);
+								const delt=Math.max(0,num+current.hujia-5);
+								eff-=att*delt;
+							});
+							return eff>0?1:0;
+						},
+					},
+				},
+				subSkill:{
+					xiangsicunwei:{
+						trigger:{
+							global:['loseAfter','equipAfter','loseAsyncAfter','cardsDiscardAfter'],
+						},
+						forced:true,
+						silent:true,
+						firstDo:true,
+						filter(event,player){
+							const nameList=['shan','tao','jiu'];
+							return event.getd().some(card=>{
+								return nameList.includes(get.name(card,false))&&get.position(card,true)==='d';
+							});
+						},
+						async content(event,trigger,player){
+							const nameList = ['shan','tao','jiu'];
+							const cards = trigger.getd().filter(card => {
+								return nameList.includes(get.name(card, false)) && get.position(card, true) === 'd';
+							});
+							await game.cardsGotoSpecial(cards);
+							game.log(cards, '被移出了游戏');
+						}
+					},
+				},
+			},
 			//杨奉
 			mbxuetu:{
 				audio:2,
@@ -1690,6 +2424,9 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 						},
 					},
 				},
+				ai:{
+					combo:'twjichou'
+				}
 			},
 			//李遗
 			jiaohua:{
@@ -15899,6 +16636,11 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					return '转换技。出牌阶段限一次，阴：你可以回复1点体力，然后令一名角色弃置两张牌；<span class="bluetext">阳：你可以摸一张牌，然后对一名角色造成1点伤害。</span>';
 				}
 			},
+			mbzuoyou(player){
+				const mbzuoyou = player.storage.mbzuoyou;
+				if (mbzuoyou) return '转换技。出牌阶段限一次，阴：你可以令一名角色摸三张牌，然后其弃置两张牌；<span class="bluetext">阳：你可以令一名角色弃置一张手牌，然后其获得1点护甲。</span>'
+				return '转换技。出牌阶段限一次，<span class="bluetext">阴：你可以令一名角色摸三张牌，然后其弃置两张牌；</span>阳：你可以令一名角色弃置一张手牌，然后其获得1点护甲。'
+			}
 		},
 		perfectPair:{
 			simazhao:['simayi','jin_simayi','jin_wangyuanji'],
@@ -16790,6 +17532,36 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			mbxuetu_fail_info:'转换技。出牌阶段限一次，阴：你可以回复1点体力，然后令一名角色弃置两张牌；阳：你可以摸一张牌，然后对一名角色造成1点伤害。',
 			mbweiming:'威命',
 			mbweiming_info:'使命技，锁定技。①出牌阶段开始时，你记录一名未以此法记录过的角色。②成功：当你杀死一名未被〖威命①〗记录过的角色后，修改〖血途〗为成功版本。③失败：当一名被〖威命①〗记录过的角色死亡后，你修改〖血途〗为失败版本。',
+			lizhaojiaobo:'李昭焦伯',
+			mbzuoyou:'佐佑',
+			mbzuoyou_info:'转换技。出牌阶段限一次，阴：你可以令一名角色摸三张牌，然后其弃置两张牌；阳：你可以令一名角色弃置一张手牌，然后其获得1点护甲。',
+			mbshishou:'侍守',
+			mbshishou_info:'锁定技。当你发动〖佐佑〗后，若目标角色不为你，你执行〖佐佑〗中目标角色未执行的一项。',
+			chengji:'成济',
+			mbkuangli:'狂戾',
+			mbkuangli_info:'锁定技。①出牌阶段开始时，你随机令场上任意名其他角色获得“狂戾”标记。②出牌阶段限两次。当你使用牌指定有“狂戾”的角色为目标后，你与其各随机弃置一张牌，然后你摸一张牌。③回合结束时，你移除所有角色的“狂戾”。',
+			mbxiongsi:'凶肆',
+			mbxiongsi_info:'限定技。出牌阶段，若你的手牌数不少于三张，你可以弃置所有手牌，然后令所有其他角色依次失去1点体力。',
+			mb_sp_guanqiujian:'SP毌丘俭',
+			mb_sp_guanqiujian_prefix:'SP',
+			mbcuizhen:'摧阵',
+			mbcuizhen_info:'①游戏开始时，你可以废除至多两名其他角色的武器栏。②当你于出牌阶段使用伤害类牌指定其他角色为目标后，若目标角色的手牌数不小于体力值，你可以废除其武器栏。③摸牌阶段，你令额定摸牌数+X（X为所有角色被废除的武器栏数之和，至多为2）。',
+			mbkuili:'溃离',
+			mbkuili_info:'锁定技。当你受到伤害后，你弃置等同于伤害值的手牌；若来源有被废除的武器栏，你令其恢复武器栏。',
+			mb_caomao:'手杀曹髦',
+			mb_caomao_prefix:'手杀',
+			mbqianlong:'潜龙',
+			mbqianlong_info:'①游戏开始时，你获得20枚“道心”标记。②当你得到牌后/受到1点伤害后/造成1点伤害后，你获得5/10/15枚“道心”（上限为100枚）。③若你的“道心”数不小于25/50/75/100，你视为拥有〖清正〗/〖酒诗〗/〖放逐〗/〖决进〗。',
+			mbcmqingzheng:'清正',
+			mbcmqingzheng_info:'出牌阶段开始时，你可以弃置两种花色的所有手牌，并观看一名有手牌的其他角色的手牌，你弃置其中一种花色的所有牌。若其被弃置的牌数小于你以此法弃置的牌数，你对其造成1点伤害。',
+			mbcmjiushi:'酒诗',
+			mbcmjiushi_info:'①当你需要使用【酒】时，若你的武将牌正面向上，你可以翻面，视为使用一张【酒】。②当你受到伤害后，若你的武将牌背面向上，你可以翻面。③当你翻面后，你获得牌堆里的一张锦囊牌。',
+			mbcmfangzhu:'放逐',
+			mbcmfangzhu_info:'出牌阶段限一次。你可以选择一名其他角色，选择一项：⒈令其不能使用手牌中的非锦囊牌直到其回合结束；⒉令其所有非Charlotte技能失效直到其回合结束。',
+			mbjuejin:'决进',
+			mbjuejin_info:'限定技。出牌阶段，你可以令所有角色依次将体力回复或失去至1并获得X点护甲（X为一名角色以此法变化的体力值）。然后你增加如下“向死存魏”的全局技能：当有牌进入弃牌堆后，系统将这些牌中的【闪】、【桃】和【酒】移出游戏。',
+			mbweitong:'卫统',
+			mbweitong_info:'主公技。游戏开始时，若你有〖潜龙〗，你获得20X枚“道心”（X为其他魏势力角色数）。',
 
 			mobile_standard:'手杀异构·标准包',
 			mobile_shenhua_feng:'手杀异构·其疾如风',

character/onlyOL.js

@@ -1093,7 +1093,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 				trigger:{player:'phaseJieshuBegin'},
 				prompt2:function(event,player){
 					var str='获得技能';
-					var num=lib.skill.olsbranji.getNum(event,player);
+					var num=lib.skill.olsbranji.getNum(player);
 					if(num>=player.getHp()) str+='【困奋】';
 					if(num==player.getHp()) str+='和';
 					if(num<=player.getHp()) str+='【诈降】';
@@ -1109,7 +1109,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					return str;
 				},
 				check:function(event,player){
-					var num=lib.skill.olsbranji.getNum(event,player);
+					var num=lib.skill.olsbranji.getNum(player);
 					if(num==player.getHp()) return true;
 					return player.getHandcardLimit()-player.countCards('h')>=3||player.getDamagedHp()>=2;
 				},
@@ -1120,7 +1120,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					var player=map.player;
 					var trigger=map.trigger;
 					player.awakenSkill('olsbranji');
-					var num=lib.skill.olsbranji.getNum(trigger,player);
+					var num=lib.skill.olsbranji.getNum(player);
 					const skills = [];
 					if(num>=player.getHp()){
 						skills.push('kunfen');
@@ -1159,8 +1159,14 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 				getList:function(event){
 					return event.getParent().phaseList.map(list=>list.split('|')[0]);
 				},
-				getNum:function(event,player){
+				getNum:function(player){
-					return lib.skill.olsbranji.getList(event).slice(0,event.getParent().num).filter(name=>player.getHistory('useCard',evt=>evt.getParent(name).name==name).length).length;
+					return player.getHistory('useCard',evt=>{
+						return lib.phaseName.some(name=>{
+							return evt.getParent(name).name==name;
+						});
+					}).reduce((list,evt)=>{
+						return list.add(evt.getParent(lib.phaseName.find(name=>evt.getParent(name).name==name)));
+					},[]).length;
 				},
 				subSkill:{
 					norecover:{

character/rank.js

@@ -138,6 +138,9 @@ window.noname_character_rank={
 		'dc_simashi',
 		'dc_sb_simayi',
 		'caofang',
+		'dc_shen_huatuo',
+		'sp_zhenji',
+		'wu_guanyu',
 	],
 	a:[
 		'star_caoren',
@@ -373,6 +376,7 @@ window.noname_character_rank={
 		'shen_lusu',
 		'huzun',
 		'star_zhangchunhua',
+		'mb_caomao',
 	],
 	am:[
 		'tw_yanliang',
@@ -687,6 +691,7 @@ window.noname_character_rank={
 		'dc_caoshuang',
 		'clan_wangling',
 		'clan_wangguang',
+		'lizhaojiaobo',
 	],
 	bp:[
 		'xin_huojun',
@@ -1081,6 +1086,8 @@ window.noname_character_rank={
 		'sb_gaoshun',
 		're_wangyi',
 		'ol_wangyi',
+		'chengji',
+		'mb_sp_guanqiujian',
 	],
 	b:[
 		'junk_guanyu',
@@ -1402,6 +1409,7 @@ window.noname_character_rank={
 		'jsrg_liuyong',
 		'jsrg_sunjun',
 		'xia_shie',
+		'clan_wangmingshan',
 	],
 	bm:[
 		'kongrong',
@@ -1900,6 +1908,7 @@ window.noname_character_rank={
 			'dc_guansuo',
 			'dc_xujing',
 			'caoxian',
+			'wu_guanyu',
 		],
 		epic:[
 			'dc_caoshuang',
@@ -2181,6 +2190,9 @@ window.noname_character_rank={
 			'bailingyun',
 			'dc_sb_simayi',
 			'caofang',
+			'mb_caomao',
+			'dc_shen_huatuo',
+			'sp_zhenji',
 		],
 		rare:[
 			're_wangyi',
@@ -2670,6 +2682,10 @@ window.noname_character_rank={
 			'ol_dingshangwan',
 			'ol_liwan',
 			'dc_sb_lusu',
+			'clan_wangmingshan',
+			'chengji',
+			'mb_sp_guanqiujian',
+			'lizhaojiaobo',
 		],
 		junk:[
 			'ol_sb_guanyu',

character/refresh.js

@@ -5593,6 +5593,9 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					player.loseMaxHp();
 					player.addSkills('xinpaiyi');
 				},
+				ai:{
+					combo:'xinquanji'
+				}
 			},
 			xinpaiyi:{
 				audio:2,
@@ -9325,6 +9328,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			},
 			rejiushi:{
 				audio:2,
+				audioname:['mb_caomao'],
 				group:['rejiushi1','rejiushi2','rejiushi3','rejiushi_gain'],
 				subfrequent:['gain'],
 				subSkill:{
@@ -9351,6 +9355,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					return false;
 				},
 				audio:'rejiushi',
+				audioname:['mb_caomao'],
 				enable:'chooseToUse',
 				filter:function(event,player){
 					if(player.classList.contains('turnedover')) return false;

character/sb.js

@@ -429,6 +429,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 						animate:'giveAuto',
 						gaintag:['sbquhu'],
 					}).setContent(lib.skill.sbquhu.addToExpansionMultiple);
+					debugger
 					await game.asyncDelay(1.5);
 					const isMin=minLength>myCards.length;
 					const sortedList=lose_list.filter(list=>list[0]!=player).sort((a,b)=>{
@@ -544,7 +545,9 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 						return;
 					}
 					"step 2";
+					var loopedCount=0,mapLength=Object.keys(event.gaining_map).length;
 					for(var j in event.gaining_map){
+						loopedCount++;
 						var map={};
 						var player=(_status.connectMode?lib.playerOL:game.playerMap)[j],cards=event.gaining_map[j];
 						var hs=player.getCards('x');
@@ -567,20 +570,20 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 							player.$draw(cards.length);
 							if(event.log) game.log(player,'将',get.cnNumber(cards.length),'张牌置于了武将牌上');
 							game.pause();
-							setTimeout((player,cards)=>{
+							setTimeout((player,cards,resume)=>{
 								player.$addToExpansion(cards,null,event.gaintag);
 								for(var i of event.gaintag) player.markSkill(i);
-								game.resume();
+								if(resume) game.resume();
-							},get.delayx(500,500),player,cards);
+							},get.delayx(500,500),player,cards,loopedCount===mapLength);
 						}
 						else if(event.animate=='gain'){
 							player.$gain(cards,false);
 							game.pause();
-							setTimeout((player,cards)=>{
+							setTimeout((player,cards,resume)=>{
 								player.$addToExpansion(cards,null,event.gaintag);
 								for(var i of event.gaintag) player.markSkill(i);
-								game.resume();
+								if(resume) game.resume();
-							},get.delayx(700,700),player,cards);
+							},get.delayx(700,700),player,cards,loopedCount===mapLength);
 						}
 						else if(event.animate=='gain2'||event.animate=='draw2'){
 							var gain2t=300;
@@ -588,11 +591,11 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 								gain2t=500;
 							}
 							game.pause();
-							setTimeout((player,cards)=>{
+							setTimeout((player,cards,resume)=>{
 								player.$addToExpansion(cards,null,event.gaintag);
 								for(var i of event.gaintag) player.markSkill(i);
-								game.resume();
+								if(resume) game.resume();
-							},get.delayx(gain2t,gain2t),player,cards);
+							},get.delayx(gain2t,gain2t),player,cards,loopedCount===mapLength);
 						}
 						else if(event.animate=='give'||event.animate=='giveAuto'){
 							var evtmap=event.losing_map;
@@ -632,20 +635,20 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 								}
 							}
 							game.pause();
-							setTimeout((player,cards)=>{
+							setTimeout((player,cards,resume)=>{
 								player.$addToExpansion(cards,null,event.gaintag);
 								for(var i of event.gaintag) player.markSkill(i);
-								game.resume();
+								if(resume) game.resume();
-							},get.delayx(500,500),player,cards);
+							},get.delayx(500,500),player,cards,loopedCount===mapLength);
 						}
 						else if(typeof event.animate=='function'){
 							var time=event.animate(event);
 							game.pause();
-							setTimeout((player,cards)=>{
+							setTimeout((player,cards,resume)=>{
 								player.$addToExpansion(cards,null,event.gaintag);
 								for(var i of event.gaintag) player.markSkill(i);
-								game.resume();
+								if(resume) game.resume();
-							},get.delayx(time,time),player,cards);
+							},get.delayx(time,time),player,cards,loopedCount===mapLength);
 						}
 						else{
 							player.$addToExpansion(cards,null,event.gaintag);
@@ -760,8 +763,9 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 				ai:{threaten:2.5},
 				getLimit:9,
 				getNum(num){
-					if(typeof num!='number'||!Array.from({length:9}).map((_,i)=>i+1).includes(num)) return 0;
+					const list=[2,2,5,5,1,2,2,3,3,2];
-					return [2,2,5,5,1,2,2,3,3][num-1];
+					if(typeof num!='number'||!Array.from({length:list.length}).map((_,i)=>i+1).includes(num)) return 0;
+					return list[num-1];
 				},
 				getEffect(player,num){
 					if(!player||typeof num!='number') return 0;
@@ -772,8 +776,8 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 								return get.attitude(player,target)>0&&target.isTurnedOver();
 							})) return 10;
 							return 0;
-						case 2://-2，摸min(5,max(1,阵亡角色数))的牌
+						case 2://-2，摸min(5,max(2,阵亡角色数))的牌
-							return Math.min(5,(Math.max(1,game.dead.length)));
+							return Math.min(5,(Math.max(2,game.dead.length)));
 						case 3://-5，加上限加血+复原装备栏
 							if(!game.hasPlayer(target=>{
 								return get.attitude(player,target)>0&&target.maxHp<10;
@@ -812,6 +816,11 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 								return get.attitude(player,target)<0;
 							})) return 2.5;
 							return 0;
+						case 10://-2，封印锦囊牌外的手牌
+							if(game.hasPlayer(target=>{
+								return get.attitude(player,target)<0;
+							})) return 1.5;
+							return 0;
 						default://其他
 							return 0;
 					}
@@ -833,7 +842,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 								var dialog=ui.create.dialog('行殇：请选择你要执行的一项','hidden');
 								dialog.add([[
 									[1,'移去2个“颂”标记，复原一名角色的武将牌'],
-									[2,'移去2个“颂”标记，令一名角色摸'+get.cnNumber(Math.min(5,Math.max(1,game.dead.length)))+'张牌'],
+									[2,'移去2个“颂”标记，令一名角色摸'+get.cnNumber(Math.min(5,Math.max(2,game.dead.length)))+'张牌'],
 									[3,'移去5个“颂”标记，令一名体力上限小于10的角色加1点体力上限并回复1点体力，然后随机恢复一个被废除的装备栏'],
 									[4,'移去5个“颂”标记，获得一名已阵亡角色的所有技能，然后失去〖行殇〗〖放逐〗〖颂威〗'],
 								],'textbutton']);
@@ -881,14 +890,14 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 									async content(event,trigger,player){
 										const target=event.targets[0];
 										const num=lib.skill.sbxingshang_use_backup.num;
-										player.removeMark('sbxingshang',num);
+										player.removeMark('sbxingshang',get.info('sbxingshang').getNum(num));
 										switch(num){
 											case 1:
 												if(target.isLinked()) target.link(false);
 												if(target.isTurnedOver()) target.turnOver();
 												break;
 											case 2:
-												target.draw(Math.min(5,Math.max(1,game.dead.length)));
+												target.draw(Math.min(5,Math.max(2,game.dead.length)));
 												break;
 											case 3:
 												target.gainMaxHp();
@@ -951,7 +960,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 									case 1:
 										return str+'移去2个“颂”标记，复原一名角色的武将牌';
 									case 2:
-										return str+'移去2个“颂”标记，令一名角色摸'+get.cnNumber(Math.min(5,Math.max(1,game.dead.length)))+'张牌';
+										return str+'移去2个“颂”标记，令一名角色摸'+get.cnNumber(Math.min(5,Math.max(2,game.dead.length)))+'张牌';
 									case 3:
 										return str+'移去5个“颂”标记，令一名体力上限小于10的角色加1点体力上限并回复1点体力，然后随机恢复一个被废除的装备栏';
 									case 4:
@@ -963,7 +972,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 							order(_,player){
 								const info=get.info('sbxingshang');
 								const goon=(player.hasSkill('sbfangzhu')&&(player.getStat('skill').sbfangzhu||0)<(get.info('sbfangzhu').usable||Infinity));
-								let list=Array.from({length:goon?9:4}).map((_,i)=>i+1);
+								let list=Array.from({length:goon?10:4}).map((_,i)=>i+1);
 								list=list.filter(num=>player.countMark('sbxingshang')>=info.getNum(num));
 								list.sort((a,b)=>info.getEffect(player,b)-info.getEffect(player,a));
 								return (Array.from({length:4}).map((_,i)=>i+1).includes(list[0])&&info.getEffect(player,list[0])>0)?1:0;
@@ -976,6 +985,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			},
 			sbfangzhu:{
 				audio:2,
+				audioname:['mb_caomao'],
 				enable:'phaseUse',
 				filter(event,player){
 					return player.hasMark('sbxingshang');
@@ -989,7 +999,8 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 							[2,'移去2个“颂”标记，令一名其他角色的非Charlotte技能失效直到其回合结束'],
 							[3,'移去2个“颂”标记，令一名其他角色不能响应除其外的角色使用的牌直到其回合结束'],
 							[4,'移去3个“颂”标记，令一名其他角色将武将牌翻面'],
-							[5,'移去3个“颂”标记，令一名其他角色于手牌中只能使用装备牌直到其回合结束']
+							[5,'移去3个“颂”标记，令一名其他角色于手牌中只能使用装备牌直到其回合结束'],
+							[6,'移去2个“颂”标记，令一名其他角色于手牌中只能使用锦囊牌直到其回合结束'],
 						],'textbutton']);
 						return dialog;
 					},
@@ -998,12 +1009,12 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 						return game.hasPlayer(target=>{
 							if(target==player) return false;
 							const num=button.link,storage=target.getStorage('sbfangzhu_ban');
-							return !((num==1&&storage.includes('basic'))||(num==5&&storage.includes('equip')));
+							return !((num==1&&storage.includes('basic'))||(num==5&&storage.includes('equip'))||(num==6&&storage.includes('trick')));
 						});
 					},
 					check(button){
 						const player=get.event('player'),info=get.info('sbxingshang');
-						let list=Array.from({length:5}).map((_,i)=>i+1);
+						let list=Array.from({length:6}).map((_,i)=>i+1);
 						list=list.filter(num=>player.countMark('sbxingshang')>=info.getNum(num+4));
 						const num=list.sort((a,b)=>info.getEffect(player,b+4)-info.getEffect(player,a+4))[0]-4;
 						return (button.link==num)?10:0;
@@ -1012,25 +1023,23 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 						return {
 							num:links[0],
 							audio:'sbfangzhu',
+							audioname:['mb_caomao'],
 							filterCard:()=>false,
 							selectCard:-1,
 							filterTarget(card,player,target){
 								if(target==player) return false;
 								const num=lib.skill.sbfangzhu_backup.num,storage=target.getStorage('sbfangzhu_ban');
-								return !((num==1&&storage.includes('basic'))||(num==5&&storage.includes('equip')));
+								return !((num==1&&storage.includes('basic'))||(num==5&&storage.includes('equip'))||(num==6&&storage.includes('trick')));
 							},
 							async content(event,trigger,player){
 								const target=event.target;
 								const num=lib.skill.sbfangzhu_backup.num;
 								player.removeMark('sbxingshang',get.info('sbxingshang').getNum(num+4));
 								switch(num){
-									case 1:
+									case 1: case 2: case 6:
+										const type=['basic','equip','trick'][[1,2,6].indexOf(num)];
 										target.addTempSkill('sbfangzhu_ban',{player:'phaseEnd'});
-										target.markAuto('sbfangzhu_ban',['basic']);
+										target.markAuto('sbfangzhu_ban',[type]);
-										break;
-									case 2:
-										target.removeSkill('baiban');
-										target.addTempSkill('baiban',{player:'phaseEnd'});
 										break;
 									case 3:
 										target.addTempSkill('sbfangzhu_kill',{player:'phaseEnd'});
@@ -1062,6 +1071,8 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 												return 0;
 											case 5:
 												return -target.countCards('h',card=>get.type(card)!='equip')-3;
+											case 6:
+												return -target.countCards('h',card=>get.type2(card)!='trick')-2;
 										}
 									},
 								},
@@ -1081,6 +1092,8 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 								return str+'移去3个“颂”标记，令一名其他角色将武将牌翻面';
 							case 5:
 								return str+'移去3个“颂”标记，令一名其他角色于手牌中只能使用装备牌直到其回合结束';
+							case 6:
+								return str+'移去2个“颂”标记，令一名其他角色于手牌中只能使用锦囊牌直到其回合结束';
 						}
 					}
 				},
@@ -1088,10 +1101,10 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					order(_,player){
 						const info=get.info('sbxingshang');
 						const goon=(player.hasSkill('sbxingshang')&&(player.getStat('skill').sbxingshang_use||0)<(info.subSkill.use.usable||Infinity));
-						let list=Array.from({length:goon?9:5}).map((_,i)=>i+(goon?1:5));
+						let list=Array.from({length:goon?10:6}).map((_,i)=>i+(goon?1:5));
 						list=list.filter(num=>player.countMark('sbxingshang')>=info.getNum(num));
 						list.sort((a,b)=>info.getEffect(player,b)-info.getEffect(player,a));
-						return (Array.from({length:5}).map((_,i)=>i+5).includes(list[0])&&info.getEffect(player,list[0])>0)?1:0;
+						return (Array.from({length:6}).map((_,i)=>i+5).includes(list[0])&&info.getEffect(player,list[0])>0)?1:0;
 					},
 					result:{player:1},
 				},
@@ -1150,7 +1163,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 				forced:true,
 				locked:false,
 				async content(event,trigger,player){
-					player.addMark('sbxingshang',Math.min(get.info('sbxingshang').getLimit-player.countMark('sbxingshang'),game.countPlayer(target=>target.group=='wei'&&target!=player)));
+					player.addMark('sbxingshang',Math.min(get.info('sbxingshang').getLimit-player.countMark('sbxingshang'),2*game.countPlayer(target=>target.group=='wei'&&target!=player)));
 				},
 				group:'sbsongwei_delete',
 				subSkill:{
@@ -4973,6 +4986,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			},
 			sbqingzheng:{
 				audio:2,
+				audioname:['mb_caomao'],
 				trigger:{player:'phaseUseBegin'},
 				filter:function(event,player){
 					return player.countCards('h')>0;
@@ -7069,11 +7083,11 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			sb_caopi:'谋曹丕',
 			sb_caopi_prefix:'谋',
 			sbxingshang:'行殇',
-			sbxingshang_info:'①当一名角色受到伤害后（每回合限一次）或死亡时，你获得2个“颂”标记（你至多拥有9个“颂”标记）。②出牌阶段限两次，你可以：1.移去2个“颂”标记，令一名角色复原武将牌；2.移去2个“颂”标记，令一名角色摸X张牌（X为场上阵亡角色数，且X至少为1，至多为5）；3.移去5个“颂”标记，令一名体力上限小于10的角色加1点体力上限，回复1点体力，随机恢复一个已废除的装备栏；4.移去5个“颂”标记，获得一名阵亡角色武将牌上的所有技能，然后你失去〖行殇〗〖放逐〗〖颂威〗。',
+			sbxingshang_info:'①当一名角色受到伤害后（每回合限一次）或死亡时，你获得2个“颂”标记（你至多拥有9个“颂”标记）。②出牌阶段限两次，你可以：1.移去2个“颂”标记，令一名角色复原武将牌；2.移去2个“颂”标记，令一名角色摸X张牌（X为场上阵亡角色数，且X至少为2，至多为5）；3.移去5个“颂”标记，令一名体力上限小于10的角色加1点体力上限，回复1点体力，随机恢复一个已废除的装备栏；4.移去5个“颂”标记，获得一名阵亡角色武将牌上的所有技能，然后你失去〖行殇〗〖放逐〗〖颂威〗。',
 			sbfangzhu:'放逐',
-			sbfangzhu_info:'出牌阶段限一次，你可以：1.移去1个“颂”标记，令一名其他角色于手牌中只能使用基本牌直到其回合结束；2.移去2个“颂”标记，令一名其他角色的非Charlotte技能失效直到其回合结束；3.移去2个“颂”标记，令一名其他角色不能响应除其以外的角色使用的牌直到其回合结束；4.移去3个“颂”标记，令一名其他角色将武将牌翻面；5.移去3个“颂”标记，令一名其他角色于手牌中只能使用装备牌直到其回合结束。',
+			sbfangzhu_info:'出牌阶段限一次，你可以：1.移去1个“颂”标记，令一名其他角色于手牌中只能使用基本牌直到其回合结束；2.移去2个“颂”标记，令一名其他角色的非Charlotte技能失效直到其回合结束；3.移去2个“颂”标记，令一名其他角色不能响应除其以外的角色使用的牌直到其回合结束；4.移去3个“颂”标记，令一名其他角色将武将牌翻面；5.移去3个“颂”标记，令一名其他角色于手牌中只能使用装备牌直到其回合结束；6.移去2个“颂”标记，令一名其他角色于手牌中只能使用锦囊牌直到其回合结束。',
 			sbsongwei:'颂威',
-			sbsongwei_info:'主公技。①出牌阶段开始时，你获得Y个“颂”标记（Y为场上其他魏势力角色数）。②每局游戏限一次，出牌阶段，你可以令一名其他魏势力角色失去所有武将牌的技能。',
+			sbsongwei_info:'主公技。①出牌阶段开始时，你获得Y个“颂”标记（Y为场上其他魏势力角色数的两倍）。②每局游戏限一次，出牌阶段，你可以令一名其他魏势力角色失去所有武将牌的技能。',
 			sb_xunyu:'谋荀彧',
 			sb_xunyu_prefix:'谋',
 			sbquhu:'驱虎',

character/shenhua.js

@@ -1974,6 +1974,9 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					target.addMark('nzry_huaiju',1);
 					target.addSkill('nzry_huaiju_ai');
 				},
+				ai:{
+					combo:'nzry_huaiju'
+				}
 			},
 			"nzry_zhenglun":{
 				audio:2,
@@ -1990,6 +1993,9 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					trigger.cancel();
 					player.addMark('nzry_huaiju',1);
 				},
+				ai:{
+					combo:'nzry_huaiju'
+				}
 			},
 			"nzry_kuizhu":{
 				audio:2,
@@ -7759,7 +7765,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			zuoci:['zuoci','re_zuoci'],
 			caiwenji:['caiwenji','ol_caiwenji','re_caiwenji'],
 			xuyou:['xuyou','sp_xuyou','jsrg_xuyou','yj_xuyou','junk_xuyou'],
-			guanqiujian:['guanqiujian','re_guanqiujian','tw_guanqiujian','old_guanqiujian'],
+			guanqiujian:['guanqiujian','re_guanqiujian','tw_guanqiujian','mb_sp_guanqiujian','old_guanqiujian'],
 			chendao:['chendao','ns_chendao','old_chendao'],
 			zhugezhan:['zhugezhan','old_zhugezhan'],
 			ol_lusu:['re_lusu','ol_lusu','dc_sb_lusu'],

character/sp.js

@@ -6,7 +6,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 		characterSort:{
 			sp:{
 				sp_tianji:["sunhao","liuxie","caoang","hetaihou","sunluyu",'ol_wangrong',"zuofen","ol_bianfuren","qinghegongzhu","tengfanglan","ruiji",'caoxiancaohua'],
-				sp_sibi:["yangxiu",'guotu',"chenlin","chengyu","shixie","fuwan","wangyun","zhugejin","simalang","maliang","buzhi","dongyun","kanze","sunqian","xizhicai","sunshao",'duxi',"jianggan",'ol_dengzhi','ol_yangyi','ol_dongzhao','ol_chendeng','jin_yanghu','wangyan','xiahouxuan','quhuang','zhanghua','wangguan','sunhong','caoxi','tianchou'],
+				sp_sibi:['ol_lukai',"yangxiu",'guotu',"chenlin","chengyu","shixie","fuwan","wangyun","zhugejin","simalang","maliang","buzhi","dongyun","kanze","sunqian","xizhicai","sunshao",'duxi',"jianggan",'ol_dengzhi','ol_yangyi','ol_dongzhao','ol_chendeng','jin_yanghu','wangyan','xiahouxuan','quhuang','zhanghua','wangguan','sunhong','caoxi','tianchou'],
 				sp_tianzhu:['liyi','zhangyan','niujin','hejin','hansui',"wutugu","yanbaihu","shamoke","zhugedan",'huangzu','gaogan',"tadun","fanjiangzhangda","ahuinan","dongtuna",'ol_wenqin'],
 				sp_nvshi:['ol_dingshangwan',"lingju","guanyinping","zhangxingcai","mayunlu","dongbai","zhaoxiang",'ol_zhangchangpu',"daxiaoqiao","jin_guohuai",'ol_hujinding'],
 				sp_shaowei:["simahui","zhangbao","zhanglu","zhugeguo","xujing","zhangling",'huangchengyan','zhangzhi','lushi'],
@@ -18,7 +18,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 				sp_zhongdan:["cuiyan","huangfusong"],
 				sp_guozhan2:["sp_dongzhuo","liqueguosi","zhangren"],
 				sp_others:["hanba","caiyang"],
-				sp_waitforsort:['ol_luyusheng','ol_pengyang','ol_tw_zhangji','ol_liwan','ol_liuyan','caoyu','liupan','ol_lukai','ol_liupi'],
+				sp_waitforsort:['ol_luyusheng','ol_pengyang','ol_tw_zhangji','ol_liwan','ol_liuyan','caoyu','liupan','ol_liupi'],
 			},
 		},
 		characterFilter:{
@@ -58,7 +58,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			ol_mengda:['male','shu',4,['olgoude']],
 			ol_wanglang:['male','wei',3,['gushe','oljici']],
 			ol_liuyan:['male','qun','4/6',['olpianan','olyinji','olkuisi']],
-			lushi:['female','qun',3,['olzhuyan','olleijie']],
+			lushi:['female','qun',3,['olzhuyan','releijie']],
 			zhangshiping:['male','shu',3,['olhongji','olxinggu']],
 			sunhong:['male','wu',3,['olxianbi','olzenrun']],
 			luoxian:['male','shu',4,['oldaili']],
@@ -1718,56 +1718,86 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 				usable:1,
 				logTarget:()=>_status.currentPhase,
 				async content(event,trigger,player){
-					player.when({global:'phaseEnd'}).then(()=>{
+					player.when({global:'phaseEnd'})
+					.then(()=>{
 						if(target&&target.isIn()){
 							var num=target.countCards('h')-player.countCards('h');
 							if(num){
 								if(num>0){
 									if(player.countCards('h')<5) player.draw(Math.min(5-player.countCards('h'),num));
+									event.finish();
 								}
 								else player.chooseToDiscard(-num,'h',true);
 							}
+							else event.finish();
 						}
-					}).vars({target:_status.currentPhase});
+						else event.finish();
+					})
+					.then(()=>{
+						if(result.bool&&result.cards.length>1){
+							if(player.isDamaged()) player.recover();
+						}
+					})
+					.vars({target:_status.currentPhase});
 				},
 			},
 			olxiangzuo:{
 				audio:2,
 				trigger:{player:'dying'},
 				filter(event,player){
-					if(!_status.currentPhase||!_status.currentPhase.isIn()) return false;
+					return player.countCards('he')&&game.hasPlayer(target=>target!=player);
-					return player.countCards('he');
 				},
-				direct:true,
+				async cost(event,trigger,player){
-				limited:true,
+					event.result=await player.chooseCardTarget({
-				skillAnimation:true,
+						prompt:get.prompt2('olxiangzuo'),
-				animationColor:'water',
+						filterCard:true,
-				async content(event,trigger,player){
+						selectCard:[1,Infinity],
-					var target=_status.currentPhase,num=player.countCards('he');
+						filterTarget:lib.filter.notMe,
-					var {result:{bool,cards}}=await player.chooseToGive(get.prompt2('olxiangzuo',target),[1,num],'he').set('ai',card=>{
+						complexCard:true,
-						var player=_status.event.player,target=_status.event.target;
+						complexTarget:true,
+						complexSelect:true,
+						ai1(card){
+							const player=get.event('player');
+							if(!ui.selected.targets.length) return 0;
+							const target=ui.selected.targets[0];
 							if(player.getHistory('useSkill',evt=>{
-							return evt.skill=='olgongjie'&&evt.targets.includes(target);
+								return evt.skill=='olgongjie'&&(evt.targets||[evt.target]).includes(target);
 							}).length&&player.getHistory('useSkill',evt=>{
-							return evt.skill=='olxiangxv'&&evt.targets.includes(target);
+								return evt.skill=='olxiangxv'&&(evt.targets||[evt.target]).includes(target);
 							}).length){
 								if(get.attitude(player,target)>0) return 1;
 								if(player.canSaveCard(card,player)) return 0;
 								if(ui.selected.cards.length+player.hp>=player.maxHp) return 0;
 								return 20-get.value(card);
 							}
-						else{
 							if(get.attitude(player,target)>0&&!player.countCards('he',cardx=>player.canSaveCard(cardx,player))) return 1;
 							return 0;
-						}
+						},
-					}).set('target',target).set('complexCard',true).set('logSkill',['olxiangzuo',target]);
+						ai2(target){
-					if(!bool) return;
+							const player=get.event('player');
+							const goon=(player.getHistory('useSkill',evt=>{
+								return evt.skill=='olgongjie'&&(evt.targets||[evt.target]).includes(target);
+							}).length&&player.getHistory('useSkill',evt=>{
+								return evt.skill=='olxiangxv'&&(evt.targets||[evt.target]).includes(target);
+							}).length),att=get.attitude(player,target);
+							if(goon) return 5*att;
+							if(!!player.countCards('he',cardx=>player.canSaveCard(cardx,player))) return att;
+							return 0;
+						},
+					}).forResult();
+				},
+				limited:true,
+				skillAnimation:true,
+				animationColor:'water',
+				async content(event,trigger,player){
+					const target=event.targets[0],cards=event.cards;
 					player.awakenSkill('olxiangzuo');
+					await player.give(cards,target);
 					if(player.getHistory('useSkill',evt=>{
 						return evt.skill=='olgongjie'&&evt.targets.includes(target);
 					}).length&&player.getHistory('useSkill',evt=>{
 						return evt.skill=='olxiangxv'&&evt.targets.includes(target);
-					}).length) player.recover(cards.length);
+					}).length) await player.recover(cards.length);
 				},
 			},
 			//OL飞扬
@@ -3473,13 +3503,26 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 						return order;
 					},
 				},
-				trigger:{player:'useCard'},
+				trigger:{player:['useCard','useCardAfter']},
-				filter:function(event){
+				filter:function(event,player,name){
+					if(name=='useCardAfter'){
+						if(player.isTempBanned('olxiaofan')) return false;
+						return player.getHistory('useCard',evt=>{
+							return !player.getHistory('sourceDamage',evt2=>{
+								return evt2.card&&evt2.card==evt.card;
+							}).length&&get.tag(evt.card,'damage');
+						}).indexOf(event)>=2;
+					}
 					return [1,11,12,13].includes(get.number(event.card));
 				},
 				forced:true,
 				content:function(){
 					'step 0'
+					if(event.triggername=='useCardAfter'){
+						player.tempBanSkill('olxiaofan');
+						event.finish();
+						return;
+					}
 					trigger.targets.length=0;
 					trigger.all_excluded=true;
 					game.log(trigger.card,'被无效了');
@@ -5267,7 +5310,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 				subSkill:{
 					record:{
 						trigger:{
-							global:['phaseZhunbeiAfter','phaseBefore','enterGame'],
+							global:['phaseJieshuAfter','phaseBefore','enterGame'],
 						},
 						lastDo:true,
 						charlotte:true,
@@ -5337,6 +5380,49 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					}
 				}
 			},
+			releijie:{
+				audio:'olleijie',
+				enable:'phaseUse',
+				filterTarget:true,
+				usable:1,
+				async content(event,trigger,player){
+					const target=event.target,result=await target.judge(card=>{
+						var number=get.number(card);
+						if(get.suit(card)=='spade'&&number>=2&&number<=9) return -4;
+						return 2;
+					}).set('judge2',result=>{
+						return result.bool===false?true:false;
+					}).forResult();
+					if(result.bool) await target.draw(2);
+					else{
+						const card=new lib.element.VCard({name:'sha',nature:'thunder'});
+						if(player.canUse(card,target,false)){
+							for(let i=1;i<=2;i++){
+								await player.useCard(card,target,false);
+							}
+						}
+					}
+				},
+				ai:{
+					order:1,
+					result:{
+						target(player,target){
+							let sgn=0,eff=0,num=get.attitude(player,target);
+							const card=new lib.element.VCard({name:'sha',nature:'thunder'});
+							game.countPlayer(current=>{
+								if(!current.hasSkillTag('rejudge')) return;
+								sgn=get.sgnAttitude(player,current);
+							});
+							if(sgn>0&&player.canUse(card,target,false)){
+								eff+=get.effect(target,card,player,player)*2;
+								return eff*get.sgn(num);
+							}
+							else if(sgn==0) return num*get.sgn(num);
+							return 0;
+						},
+					},
+				},
+			},
 			//张世平
 			olhongji:{
 				audio:2,
@@ -17199,8 +17285,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 							}
 							if(list.length){
 								var skill=list.randomGet();
-								trigger.player.popup(skill);
+								trigger.player.removeSkills(skill)
-								trigger.player.disableSkill('chuanxin_disable',skill,true);
 							}
 						}
 						else{
@@ -27624,9 +27709,11 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			olxinggu_info:'①游戏开始时，你将牌堆中的三张坐骑牌扣置于武将牌上。②结束阶段，你可以将一张〖行贾①〗牌置于一名其他角色的装备区，然后你从牌堆获得一张♦牌。',
 			lushi:'卢氏',
 			olzhuyan:'驻颜',
-			olzhuyan_info:'每名角色每项各限一次。结束阶段，你可以令一名角色将以下一项调整至与其上一个准备阶段结束后相同：1.体力值；2.手牌数（体力值至多失去至1，手牌数至多摸至5；若其未执行过准备阶段则改为游戏开始时）。',
+			olzhuyan_info:'每名角色每项各限一次。结束阶段，你可以令一名角色将以下一项调整至与其上一个结束阶段结束后相同：1.体力值；2.手牌数（体力值至多失去至1，手牌数至多摸至5；若其未执行过准备阶段则改为游戏开始时）。',
 			olleijie:'雷劫',
 			olleijie_info:'准备阶段，你可以令一名角色判定，若结果为♠2~9，其受到2点雷电伤害，否则其摸两张牌。',
+			releijie:'雷劫',
+			releijie_info:'出牌阶段限一次，你可以令一名角色判定，若结果为黑桃2~9，则你视为依次对其使用两张雷【杀】，否则其摸两张牌。',
 			ol_liuyan:'OL刘焉',
 			ol_liuyan_prefix:'OL',
 			olpianan:'偏安',
@@ -27700,7 +27787,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			olxiaofan:'嚣翻',
 			olxiaofan_info:'当你需要使用不为【无懈可击】的牌时，你可以观看牌堆底的X+1张牌并使用其中的一张。此牌结算结束时，你依次弃置以下前X个区域中的所有牌：⒈判定区、⒉装备区、⒊手牌区（X为本回合你使用过的牌中包含的类型数）。',
 			oltuishi:'侻失',
-			oltuishi_info:'锁定技。①你不能使用【无懈可击】。②当你使用点数为字母的牌时，你令此牌无效并摸一张牌，且你对手牌数小于你的角色使用的下一张牌无距离和次数限制。',
+			oltuishi_info:'锁定技。①你不能使用【无懈可击】。②当你使用点数为字母的牌时，你令此牌无效并摸一张牌，且你对手牌数小于你的角色使用的下一张牌无距离和次数限制。③当你使用伤害类卡牌结算完毕后，若此牌为你本回合使用的第三张或以上未造成伤害的卡牌，则你令本回合〖器翻〗失效。',
 			ol_tw_zhangji:'张既',
 			skill_zhangji_A:'技能',
 			skill_zhangji_A_info:'出牌阶段限X次（X为你的体力值），当你使用牌指定一名其他角色为目标后，你可以观看其手牌，然后你选择一项：<br>1.弃置其一张牌，然后若弃置的牌是能造成火焰伤害的牌，你摸一张牌。<br>2.重铸其手牌中的所有【杀】和【决斗】。<br>3.若其没有【闪】，你与其互相对对方造成1点伤害。',
@@ -27746,9 +27833,9 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			olgongjie:'恭节',
 			olgongjie_info:'每轮的首个回合开始时，你可以令任意名角色获得你的一张牌，然后你摸X张牌（X为你本次失去的花色数）。',
 			olxiangxv:'相胥',
-			olxiangxv_info:'当你的手牌数变为全场最少时，你可以获得以下效果：本回合结束时，将手牌数调整至与当前回合角色手牌数相同（至多摸至五张）。',
+			olxiangxv_info:'当你的手牌数变为全场最少时，你可以获得以下效果：本回合结束时，将手牌数调整至与当前回合角色手牌数相同（至多摸至五张），然后若你以此法弃置了至少两张手牌，则你回复1点体力。',
 			olxiangzuo:'襄胙',
-			olxiangzuo_info:'限定技，当你进入濒死状态时，你可以交给当前回合角色任意张牌，若如此做，若你本回合已对其发动过〖恭节〗和〖相胥〗，你回复等量的体力。',
+			olxiangzuo_info:'限定技，当你进入濒死状态时，你可以交给一名其他角色任意张牌，然后若你本回合已对其发动过〖恭节〗和〖相胥〗，你回复等量的体力。',
 			liyi:'李异',
 			olchanshuang:'缠双',
 			olchanshuang_info:'①出牌阶段限一次，你可以选择一名其他角色。你与其依次选择〖缠双③〗的一项，然后你与其依次执行各自选择的项。②结束阶段，若X大于0，你执行〖缠双③〗的前X项（X为你本回合以任意形式执行过的〖缠双③〗的选项数）。③选项：1.重铸一张牌；2.使用一张【杀】；3.弃置两张牌。',

character/sp2.js

@@ -3865,7 +3865,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 						forced:true,
 						charlotte:true,
 						filter:function(event,player){
-							return event.skill=='xiongmang'&&!player.hasHistory('sourceDamage',function(evt){
+							return player.maxHp>1&&event.skill=='xiongmang'&&!player.hasHistory('sourceDamage',function(evt){
 								return evt.card==event.card;
 							});
 						},
@@ -4289,18 +4289,18 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 				trigger:{source:'damageBegin1'},
 				direct:true,
 				filter:function(event,player){
-					return player.countCards('he')>0&&player.isPhaseUsing()&&!player.hasSkill('chaofeng2');
+					return player.countCards('h')>0&&player.isPhaseUsing()&&!player.hasSkill('chaofeng2');
 				},
 				content:function(){
 					'step 0'
-					var str='弃置一张牌并摸一张牌',color,type;
+					var str='弃置一张手牌并摸一张牌',color,type;
 					if(trigger.card){
 						type=get.type2(trigger.card,false);
 						color=get.color(trigger.card,false);
 						if(color!='none') str+='；若弃置'+get.translation(color)+'牌则改为摸两张牌';
 						if(type) str+='；若弃置类型为'+get.translation(type)+'的牌则伤害+1';
 					}
-					var next=player.chooseToDiscard('he',get.prompt('chaofeng',trigger.player),str);
+					var next=player.chooseToDiscard('h',get.prompt('chaofeng',trigger.player),str);
 					next.set('ai',function(card){
 						var player=_status.event.player,att=_status.event.att;
 						var val=4.2-get.value(card);
@@ -6243,7 +6243,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 				direct:true,
 				charlotte:true,
 				filter:function(event,player){
-					if(player!=_status.currentPhase) return false;
+					if(player!=_status.currentPhase||event.targets.length!=1) return false;
 					var card=event.card;
 					if(card.name!='sha'&&get.type(card)!='trick')return false;
 					var info=get.info(card);
@@ -11389,7 +11389,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			hfjieying:'节应',
 			hfjieying2:'节应',
 			hfjieying3:'节应',
-			hfjieying_info:'结束阶段，你可以选择一名其他角色，该角色下回合使用【杀】或普通锦囊牌无距离限制且可多指定一个目标，且当其造成伤害后，其无法再使用牌直到回合结束。',
+			hfjieying_info:'结束阶段，你可以选择一名其他角色，该角色下回合使用目标数为1的【杀】或普通锦囊牌无距离限制且可多指定一个目标，且当其造成伤害后，其无法再使用牌直到回合结束。',
 			weipo:'危迫',
 			weipo_info:'锁定技，其他角色使用【杀】或普通锦囊牌指定你为目标后，若你的手牌数小于X，则你将手牌摸至X张，并记录摸牌事件结算后的手牌数Y。此牌结算结束后，若你的手牌数小于Y，则你将一张手牌交给此牌的使用者，且此技能失效直到你的下回合开始。（X为你的体力上限且至多为5）',
 			zhaozhong:'赵忠',
@@ -11499,7 +11499,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			fengshi_info:'当你使用牌指定第一个目标后，你可弃置你与其中一名手牌数小于你的目标角色的各一张牌，并令此牌对其造成的伤害+1；当你成为其他角色使用牌的目标后，若你的手牌数小于其，则你可以弃置你与其的各一张牌，并令此牌对你造成的伤害+1。',
 			tongyuan:'童渊',
 			chaofeng:'朝凤',
-			chaofeng_info:'出牌阶段限一次。当你造成伤害时，你可以弃置一张牌，然后摸一张牌。若此伤害的渠道为牌且你弃置的牌：与此牌颜色相同，则你改为摸两张牌；与此牌类型相同，则此伤害+1。',
+			chaofeng_info:'出牌阶段限一次。当你造成伤害时，你可以弃置一张手牌，然后摸一张牌。若此伤害的渠道为牌且你弃置的牌：与此牌颜色相同，则你改为摸两张牌；与此牌类型相同，则此伤害+1。',
 			chuanshu:'传术',
 			chuanshu_info:'限定技。准备阶段，若你已受伤；或当你死亡时，你可令一名其他角色获得〖朝凤〗。然后你获得〖龙胆〗、〖从谏〗和〖穿云〗。',
 			chuanyun:'穿云',
@@ -11526,7 +11526,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			yinyi_info:'锁定技。每回合限一次，当你受到非属性伤害时，若你的手牌数和体力值与伤害来源均不相同，则你防止此伤害。',
 			haomeng:'郝萌',
 			xiongmang:'雄莽',
-			xiongmang_info:'你可将任意张花色各不相同的手牌当做目标数上限为X的【杀】使用（X为此【杀】对应的实体牌数）。此【杀】使用结算结束后，若你未造成过渠道为此牌的伤害，则你减1点体力上限。',
+			xiongmang_info:'你可将任意张花色各不相同的手牌当做目标数上限为X的【杀】使用（X为此【杀】对应的实体牌数）。此【杀】使用结算结束后，若你未造成过渠道为此牌的伤害且体力上限大于1，则你减1点体力上限。',
 			yanfuren:'严夫人',
 			channi:'谗逆',
 			channi_info:'出牌阶段限一次。你可将任意张手牌交给一名其他角色，然后其可以将至多等量的手牌当做【决斗】使用。若其因此【决斗】造成了伤害，则其摸X张牌（X为此【决斗】对应的实体牌数）。若其因此【决斗】受到过伤害，则你弃置所有手牌。',
@@ -11572,7 +11572,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			dcruizhan:'锐战',
 			dcruizhan_info:'其他角色的准备阶段开始时，若其的手牌数不小于其体力值，则你可以和其拼点。若你赢或拼点牌中有【杀】，则你视为对其使用一张【杀】。然后若此【杀】造成了伤害且以上两个条件均被满足，则你获得其一张牌。',
 			dcshilie:'示烈',
-			dcshilie_info:'①出牌阶段限一次。你可以选择一项：⒈回复1点体力，将两张牌置于武将牌上作为“示烈”。若“示烈”牌数大于存活人数，则你将最早的多余牌置入弃牌堆；⒉失去1点体力，获得两张“示烈”牌。（满血则不回血，无牌则不移动）②当你死亡时，你可以将所有“示烈”牌交给一名其他角色。',
+			dcshilie_info:'①出牌阶段限一次。你可以选择一项：⒈回复1点体力，将两张牌置于武将牌上作为“示烈”。若“示烈”牌数大于存活人数，则你将最早的多余牌置入弃牌堆；⒉失去1点体力，获得两张“示烈”牌。（满血则不回血，无牌则不移动）②当你死亡时，你可以将所有“示烈”牌交给一名不为伤害来源的其他角色。',
 			dc_zhaoyǎn:'赵俨',
 			dcfuning:'抚宁',
 			dcfuning_info:'当你使用牌时，你可以摸两张牌，然后弃置X张牌（X为你本回合内发动过〖抚宁〗的次数）。',

character/tw.js

@@ -369,7 +369,10 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					backup:{
 						viewAs:{name:'juedou'},
 						position:'he',
-						filterCard:true,
+						filterCard(card,player){
+							const cardx=get.autoViewAs({name:'juedou'},[card]);
+							return lib.filter.targetEnabledx(cardx,player,get.event('sourcex'));
+						},
 						check(card){
 							if(get.name(card)=='sha') return 5-get.value(card);
 							return 8-get.value(card);
@@ -712,7 +715,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 						forced:true,
 						popup:false,
 						async content(event,trigger,player){
-							player.logSkill('twxiayong'+(trigger.player===player?'1':'2'),trigger.player);
+							await player.logSkill('twxiayong'+(trigger.player===player?'1':'2'),trigger.player);
 							if(trigger.player===player){
 								const cards=player.getCards('h',card=>{
 									return lib.filter.cardDiscardable(card,player,'twxiayong');
@@ -16738,6 +16741,8 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			twjuexing:'绝行',
 			twjuexing_info:'出牌阶段限一次。你可以视为对一名其他角色使用一张【决斗】。此牌对一名角色生效时，你与其将所有手牌扣置于武将牌上，然后各摸等同于当前体力值的牌。此牌结算结束后，你与所有目标角色弃置本次以此法摸的牌，然后获得扣置于武将牌上的牌。历战：当你因〖绝行〗摸牌时，摸牌数+1。',
 			twxiayong:'狭勇',
+			twxiayong1:'狭勇',
+			twxiayong2:'狭勇',
 			twxiayong_info:'锁定技。当你使用的【决斗】或目标角色包括你的【决斗】造成伤害时，若受伤角色为你，则你随机弃置一张手牌；否则你令此伤害+1。',
 			twqiaosi:'峭嗣',
 			twqiaosi_info:'结束阶段，你可以获得由其他角色区域直接置入或经由处理区置入弃牌堆的所有牌，然后若你以此法获得的牌数小于你的体力值，则你失去1点体力。',

character/xianding.js

@@ -4,6 +4,8 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 		name:'xianding',
 		connect:true,
 		character:{
+			sp_zhenji:['female','qun',3,['dcjijie','dchuiji']],
+			wu_guanyu:['male','shu',5,['dcjuewu','dcwuyou','dcyixian']],
 			caofang:['male','wei',4,['dczhimin','dcjujian'],['zhu']],
 			dc_sb_simayi:['male','wei',3,['dcsbquanmou','dcsbpingliao']],
 			chendong:['male','wu',4,['dcduanxie','fenming']],
@@ -114,7 +116,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 				sp2_yuxiu:['dongguiren','dc_tengfanglan','zhangjinyun','zhoubuyi','dc_xujing'],
 				sp2_qifu:['dc_guansuo','xin_baosanniang','dc_zhaoxiang'],
 				sp2_gaoshan:['wanglang','liuhui','zhangjian'],
-				sp2_wumiao:['wu_zhugeliang','wu_luxun'],
+				sp2_wumiao:['wu_zhugeliang','wu_luxun','wu_guanyu'],
 				sp2_mouding:['dc_sb_lusu','dc_sb_zhouyu','dc_sb_simayi'],
 			}
 		},
@@ -123,6 +125,514 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			],
 		},
 		skill:{
+			//武关羽
+			dcjuewu:{
+				audio:2,
+				enable:'chooseToUse',
+				filter(event,player){
+					if(!player.hasCard(card=>{
+						return _status.connectMode||get.number(card)===2;
+					},'hes')) return false;
+					for(const name of ['shuiyanqijuny'].concat(lib.inpile)){
+						if(player.getStorage('dcjuewu_used').includes(name)) continue;
+						const card=get.autoViewAs({name},'unsure');
+						if(!get.tag(card,'damage')) continue;
+						if(event.filterCard(card,player,event)) return true;
+						if(name==='sha'){
+							for(const nature of lib.inpile_nature){
+								card.nature=nature;
+								if(event.filterCard(card,player,event)) return true;
+							}
+						}
+					}
+					return false;
+				},
+				hiddenCard(player,name){
+					if(!lib.inpile.includes(name)) return false;
+					if(player.getStorage('dcjuewu_used').includes(name)) return false;
+					if(!player.hasCard(card=>{
+						return _status.connectMode||get.number(card)===2;
+					},'hes')) return false;
+					return get.tag({name},'damage');
+				},
+				group:'dcjuewu_inTwo',
+				chooseButton:{
+					dialog(event,player){
+						let list=get.inpileVCardList(info=>{
+							return get.tag({name:info[2]},'damage');
+						});
+						if(!list.some(info=>info[2]==='shuiyanqijuny')) list.add(['锦囊','','shuiyanqijuny']);
+						list=list.filter(info=>{
+							const name=info[2],nature=info[3];
+							if(player.getStorage('dcjuewu_used').includes(name)) return false;
+							const card=get.autoViewAs({name,nature},'unsure');
+							return event.filterCard(card,player,event);
+						});
+						return ui.create.dialog('绝武',[list,'vcard']);
+					},
+					check(button){
+						if(get.event().getParent().type!='phase') return 1;
+						const player=get.player();
+						return player.getUseValue({
+							name:button.link[2],
+							nature:button.link[3],
+						});
+					},
+					backup(links,player){
+						return {
+							audio:'dcjuewu',
+							filterCard(card,player){
+								return get.number(card)===2;
+							},
+							position:'hes',
+							check(card){
+								return 8-get.value(card);
+							},
+							popname:true,
+							viewAs:{
+								name:links[0][2],
+								nature:links[0][3]
+							},
+							precontent(){
+								if (!player.storage.dcjuewu_used){
+									player.when({global:'phaseAfter'}).then(() => {
+										delete player.storage.dcjuewu_used;
+									});
+								}
+								player.markAuto('dcjuewu_used', event.result.card.name);
+							},
+						}
+					},
+					prompt(links,player){
+						return '将一张点数为2的牌当'+(get.translation(links[0][3])||'')+get.translation(links[0][2])+'使用';
+					}
+				},
+				subSkill:{
+					backup:{},
+					inTwo:{
+						audio:'dcjuewu',
+						trigger:{
+							player:'gainAfter',
+							global:'loseAsyncAfter',
+						},
+						filter(event,player){
+							const cards=event.getg(player);
+							if(!cards.length) return false;
+							return game.hasPlayer(current=>{
+								if(current===player) return false;
+								const evt=event.getl(current);
+								return evt&&evt.hs.length+evt.es.length+evt.js.length>0;
+							});
+						},
+						forced:true,
+						locked:false,
+						async content(event,trigger,player){
+							player.addGaintag(trigger.getg(player),'dcjuewu_two');
+							player.addSkill('dcjuewu_two');
+						},
+					},
+					two:{
+						charlotte:true,
+						mod:{
+							cardnumber(card){
+								if(card.hasGaintag('dcjuewu_two')) return 2;
+							},
+						},
+					},
+				},
+				ai:{
+					fireAttack:true,
+					respondSha:true,
+					skillTagFilter(player){
+						if(!player.hasCard(card=>{
+							return _status.connectMode||get.number(card)===2;
+						},'hes')) return false;
+					},
+					order:1,
+					result:{
+						player(player){
+							if(get.event('dying')) return get.attitude(player,get.event('dying'));
+							return 1;
+						},
+					},
+				},
+			},
+			dcwuyou:{
+				audio:2,
+				global:'dcwuyou_g',
+				subSkill:{
+					g:{
+						audio:'dcwuyou',
+						enable:'phaseUse',
+						usable:1,
+						filter(event,player){
+							if(!player.countCards('h')) return false;
+							return game.hasPlayer(current=>{
+								return current.hasSkill('dcwuyou');
+							});
+						},
+						filterCard:true,
+						filterTarget(card,player,target){
+							return target.hasSkill('dcwuyou');
+						},
+						selectTarget(){
+							const count=game.countPlayer(current=>{
+								return current.hasSkill('dcwuyou');
+							});
+							return count>1?1:-1;
+						},
+						check(card){
+							const player=get.player();
+							const hasFriend=game.hasPlayer(current=>{
+								return current.hasSkill('dcwuyou')&&get.attitude(player,current)>0;
+							});
+							return (hasFriend?7:1)-get.value(card);
+						},
+						prompt(){
+							const player=get.player(),list=game.filterPlayer(current=>{
+								return current.hasSkill('dcwuyou');
+							}),list2=list.filter(current=>current!==player);
+							const moreThanOne=list.length>1,includesMe=list.includes(player);
+							let str='选择一张手牌，';
+							if(includesMe) str+=`点击“确定”，${moreThanOne?'或':''}`;
+							if(moreThanOne||!includesMe) str+=`将此牌交给${get.translation(list2)}${list2.length>1?'中的一人':''}，`;
+							str+='然后执行后续效果。';
+							return str;
+						},
+						discard:false,
+						lose:false,
+						delay:false,
+						async content(event,trigger,player){
+							const { target } = event;
+							const isMe = target === player;
+							let { cards } = event;
+							if (!isMe) await player.give(cards, target);
+							const names = lib.inpile.filter(name => {
+								return get.type2(name) !== 'equip';
+							}).randomGets(5);
+							if (names.includes('sha')) names.splice(names.indexOf('sha') + 1, 0, ...lib.inpile_nature.map(nature => ['sha', nature]));
+							const vcard = names.map(namex => {
+								let name = namex, nature;
+								if (Array.isArray(namex)) [name, nature] = namex;
+								const info = [get.type(name), '', name, nature];
+								return info;
+							});
+							const links = await target.chooseButton(['武佑：选择一个牌名', [vcard, 'vcard']], true)
+								.set('user', player)
+								.set('ai', button => {
+									const player = get.player(), user = get.event('user');
+									return user.getUseValue({name: button.link[2], nature: button.link[3]}) * get.attitude(player, user);
+								})
+								.forResultLinks();
+							if (!links || !links.length) return;
+							const viewAs = {name: links[0][2], nature: links[0][3]};
+							if (!isMe) {
+								cards = await target.chooseToGive(player, true).forResultCards();
+							}
+							const card = cards[0];
+							if (!target.storage.dcwuyou_transfer) target.storage.dcwuyou_transfer = {};
+							target.storage.dcwuyou_transfer[card.cardid] = viewAs;
+							target.addGaintag(cards, 'dcwuyou_transfer');
+							target.addSkill('dcwuyou_transfer');
+						},
+						ai:{
+							order:10,
+							result:{
+								player(player,target){
+									if(get.attitude(player,target)>0) return 2;
+									return 1;
+								},
+								target:0.5,
+							},
+						},
+					},
+					transfer:{
+						trigger:{player:'useCard1'},
+						forced:true,
+						popup:false,
+						charlotte:true,
+						filter(event,player){
+							if(event.addCount===false) return false;
+							return player.hasHistory('lose',evt=>{
+								if(evt.getParent()!=event) return false;
+								for(const i in evt.gaintag_map){
+									if(evt.gaintag_map[i].includes('dcwuyou_transfer')) return true;
+								}
+								return false;
+							});
+						},
+						async content(event,trigger,player){
+							trigger.addCount = false;
+							const stat = player.getStat().card, name = trigger.card.name;
+							if (typeof stat[name] === 'number') stat[name]--;
+						},
+						mod:{
+							cardname(card,player){
+								const map=player.storage.dcwuyou_transfer;
+								if(map&&map[card.cardid]&&get.itemtype(card)=='card'&&card.hasGaintag('dcwuyou_transfer')) return map[card.cardid].name;
+							},
+							cardnature(card,player){
+								const map=player.storage.dcwuyou_transfer;
+								if(map&&map[card.cardid]&&get.itemtype(card)=='card'&&card.hasGaintag('dcwuyou_transfer')) return map[card.cardid].nature||false;
+							},
+							cardUsable(card){
+								if(!card.cards) return;
+								if(card.cards.some(card=>card.hasGaintag('dcwuyou_transfer'))) return Infinity;
+							},
+						},
+					},
+				}
+			},
+			dcyixian:{
+				audio:2,
+				enable:'phaseUse',
+				limited:true,
+				skillAnimation:true,
+				animationColor:'metal',
+				chooseButton:{
+					dialog(event,player){
+						const dialog=ui.create.dialog('义贤：你可以选择一项','hidden');
+						dialog.add([[
+							['field','获得场上的所有装备牌'],
+							['discardPile','获得弃牌堆中的所有装备牌']
+						],'textbutton']);
+						return dialog;
+					},
+					check(button){
+						const player=get.player();
+						if(button.link=='field') return game.filterPlayer().map(current=>{
+							const cards=current.getCards('e'),att=get.sgnAttitude(player,current);
+							return cards.map(card=>{
+								return Math.max(player.hasSkill('dcjuewu')?5:0,get.value(card,player))-get.value(card,current)*att;
+							}).reduce((p,c)=>p+c,0);
+						}).reduce((p,c)=>p+c,0);
+						if(button.link=='discardPile') return Array.from(ui.discardPile.childNodes).filter(card=>{
+							return get.type(card)==='equip';
+						}).map(card=>{
+							return Math.max(player.hasSkill('dcjuewu')?5:0,get.value(card,player));
+						}).reduce((p,c)=>p+c,0);
+						return 0.1;
+					},
+					backup(links){
+						return {
+							filterCard:()=>false,
+							selectCard:-1,
+							pos:links[0],
+							filterTarget:()=>false,
+							selectTarget:-1,
+							popup:false,
+							direct:true,
+							async content(event,trigger,player){
+								await player.logSkill('dcyixian');
+								player.awakenSkill('dcyixian');
+								const position = lib.skill.dcyixian_backup.pos;
+								let cards = [];
+								if (position === 'field') {
+									cards.addArray(game.filterPlayer().map(current => current.getCards('e')).flat());
+								}
+								else {
+									cards.addArray(Array.from(ui.discardPile.childNodes).filter(card => {
+										return get.type(card) === 'equip';
+									}));
+								}
+								if (!cards.length) return;
+								await player.gain(cards, position === 'field'? 'give' : 'gain2');
+								const pairs = game.filterPlayer().map(current => {
+									let lostNum = 0;
+									current.checkHistory('lose', evt => {
+										if (evt.getParent(2) === event) lostNum += evt.cards2.length;
+									});
+									return [current, lostNum];
+								});
+								for (const pair of pairs) {
+									const [target, num] = pair;
+									if (!num) continue;
+									const bool = await player.chooseBool(`是否令${get.translation(target)}摸${get.cnNumber(num)}张牌并回复1点体力？`)
+										.set('choice', get.effect(target, {name: 'draw'}, player, player) + get.recoverEffect(target, player, player) / 5 > 0)
+										.forResultBool();
+									if (bool) {
+										player.line(target, 'green');
+										await target.draw(num);
+										await target.recover();
+									}
+									if (!event.isMine() && !event.isOnline()) await game.asyncDelayx();
+								}
+							},
+						}
+					},
+					prompt(links){
+						return `点击“确定”，从${links[0]==='field'?'场上':'弃牌堆中'}获得所有装备牌`;
+					},
+				},
+				subSkill:{
+					backup:{},
+				},
+				ai:{
+					order:10,
+					threaten:2.9,
+					result:{
+						player(player){
+							const enemies=game.filterPlayer(current=>{
+								return get.rawAttitude(player,current)<0&&get.attitude(player,current)>=0;
+							}),knownEnemies=game.filterPlayer(current=>{
+								return get.attitude(player,current)<0;
+							});
+							if(!knownEnemies.length&&player.countCards('e')>1||player.getHp()>3&&enemies.length>0&&knownEnemies.length<2&&knownEnemies.length<enemies.length&&!knownEnemies.some(enemy=>get.attitude(player,enemy)<=-9)) return 0;
+							const val1=game.filterPlayer().map(current=>{
+								const cards=current.getCards('e'),att=get.sgnAttitude(player,current);
+								return cards.map(card=>{
+									return Math.max(player.hasSkill('dcjuewu')?5:0,get.value(card,player))-get.value(card,current)*att;
+								}).reduce((p,c)=>p+c,0);
+							}).reduce((p,c)=>p+c,0);
+							const val2=Array.from(ui.discardPile.childNodes).filter(card=>{
+								return get.type(card)==='equip';
+							}).map(card=>{
+								return Math.max(player.hasSkill('dcjuewu')?5:0,get.value(card,player));
+							}).reduce((p,c)=>p+c,0);
+							return Math.max(val1,val2)>20?4:0;
+						},
+					},
+				},
+			},
+			//SP甄宓
+			dcjijie:{
+				audio:2,
+				trigger:{
+					global:['gainAfter','loseAsyncAfter','recoverAfter'],
+				},
+				getIndex(event,player){
+					if (event.name!=='loseAsync') return [[event.player]];
+					return [game.filterPlayer(current=>{
+						return current!==player&&_status.currentPhase!==current&&event.getg(current).length>0;
+					}).sortBySeat()];
+				},
+				filter(event,player,triggername,targets){
+					if(event.name==='recover') return targets[0]!==player&&_status.currentPhase!==targets[0]&&player.isDamaged();
+					return targets.some(current=>{
+						return current!==player&&_status.currentPhase!==current&&event.getg(current).length>0;
+					});
+				},
+				forced:true,
+				usable:1,
+				logTarget(event,player,triggername,targets){
+					return targets;
+				},
+				async content(event,trigger,player){
+					if (trigger.name === 'recover') {
+						await player.recover(trigger.num);
+					}
+					else{
+						const count = game.countPlayer(current => {
+							if(current === player || _status.currentPhase === current) return 0;
+							return trigger.getg(current).length;
+						});
+						await player.draw(count);
+					}
+				},
+			},
+			dchuiji:{
+				audio:2,
+				enable:'phaseUse',
+				usable:1,
+				filterTarget:true,
+				chooseButton:{
+					dialog(event,player){
+						const name=get.translation(event.result.targets[0]);
+						const dialog=ui.create.dialog(
+							`惠济：请选择要令${name}执行的选项`,
+							[[['draw','令其摸两张牌'],['equip','令其随机使用牌堆中的一张装备牌']],'textbutton'],
+							'hidden'
+						);
+						return dialog;
+					},
+					filter(button,player){
+						const target=get.event().getParent().result.targets[0];
+						const link=button.link;
+						if(button.link==='equip'&&target.isMin()) return false;
+						return true;
+					},
+					check(button){
+						const player=get.player(),target=get.event().getParent().result.targets[0];
+						const link=button.link;
+						const att=get.attitude(player,target)/5;
+						const hs=target.countCards('h');
+						if(link==='draw'){
+							return (2-(hs+2>game.countPlayer())*hs)*att;
+						}
+						return (1.1-(hs>game.countPlayer())*hs)*att;
+					},
+					backup(links){
+						return {
+							audio:'dchuiji',
+							target:get.event().result.targets[0],
+							link:links[0],
+							filterTarget(card,player,target){
+								return target===lib.skill.dchuiji_backup.target;
+							},
+							selectTarget:-1,
+							async content(event,trigger,player){
+								const link = lib.skill.dchuiji_backup.link;
+								const { target } = event;
+								if (link === 'draw') await target.draw(2);
+								else {
+									const card = get.cardPile2(card => {
+										if (get.type(card) !== 'equip') return false;
+										return target.canUse(card, target) && !get.cardtag(card, 'gifts');
+									});
+									if (card) await target.chooseUseTarget(card, true).set('nopopup', true);
+									else {
+										game.log('但是牌堆里没有', target, '的装备！');
+										await game.asyncDelayx();
+									}
+								}
+								if (target.countCards('h') <= game.countPlayer()) return;
+								player.when({global: 'wuguRemained'}).filter(evt => {
+									return evt.getParent(3) === event;
+								}).vars({originalOwner: target}).then(() => {
+									const remained = trigger.remained.filterInD('d');
+									if (!remained.length) return event.finish();
+									player.line(originalOwner);
+									originalOwner.gain(remained, 'gain2');
+								});
+								await target.chooseUseTarget({
+									name: 'wugu', 
+									storage: {
+										fixedShownCards: target.getCards('h'),
+									},
+								}, true);
+							}
+						};
+					},
+					prompt(links){
+						return '点击“确定”以执行效果';
+					},
+				},
+				subSkill:{
+					backup:{},
+				},
+				ai:{
+					order(item,player){
+						if(!game.hasPlayer(current=>current!==player&&get.attitude(player,current)>0)&&game.hasPlayer(current=>get.attitude(player,current)<=0)) return 10;
+						if(game.hasPlayer(current=>{
+							const del=player.countCards('h')-current.countCards('h'),toFind=[2,4].find(num=>Math.abs(del)===num);
+							if(toFind===4&&del<0&&get.attitude(player,current)<=0){
+								return true;
+							}
+							return false;
+						})) return 10;
+						return 1;
+					},
+					result:{
+						target(player,target){
+							const del=player.countCards('h')-target.countCards('h'),toFind=[2,4].find(num=>Math.abs(del)===num);
+							if(toFind){
+								return -del*(get.attitude(player,target)*Math.min(3,target.countCards('h')))*toFind/10;
+							}
+							return -1;
+						},
+					},
+				},
+			},
 			//曹芳
 			dczhimin:{
 				audio:2,
@@ -1288,7 +1798,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 				audio:2,
 				trigger:{player:'useCardToPlayered'},
 				filter:function(event,player){
-					return event.isFirstTarget;
+					return event.isFirstTarget && event.targets.some(target => target != player);
 				},
 				usable:1,
 				direct:true,
@@ -1985,42 +2495,59 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 							if(!event.source||!event.source.isIn()) return false;
 							return event.player.getExpansions('dcxiaoyin').length;
 						},
-						direct:true,
+						//direct:true,
-						content:function*(event,map){
+						async cost(event, trigger, player){
-							var player=map.player,trigger=map.trigger;
+							const source = trigger.source, target = trigger.player;
-							var source=trigger.source,target=trigger.player;
+							const cards = target.getExpansions('dcxiaoyin');
-							var cards=target.getExpansions('dcxiaoyin');
 							if (trigger.hasNature('fire')) {
-								var types=cards.map(i=>get.type2(i,false));
+								const types = cards.map(i => get.type2(i, false));
-								var str=get.translation(types).replace(/(.*)、/, '$1或');
+								const str = get.translation(types).replace(/(.*)、/, '$1或');
-								var result=yield source.chooseCard(`硝引：是否弃置一张${str}牌？`,`若如此做，将${get.translation(target)}的所有“硝引”牌置入弃牌堆，令你对其造成的伤害+1`,'he',function(card,player){
+								event.result = await source.chooseCard(`硝引：是否弃置一张${str}牌？`, `若如此做，将${get.translation(target)}的对应的“硝引”牌置入弃牌堆，令你对其造成的伤害+1`, 'he', function (card, player) {
 									if (!get.event('types').includes(get.type2(card))) return false;
 									return lib.filter.cardDiscardable.apply(this, arguments);
 								}).set('types', types).set('ai', card => {
 									if (get.event('goon')) return 7 - get.value(card);
 									return 0;
-								}).set('goon',get.damageEffect(target,player,player,'fire')>0&&get.attitude(player,target)<=0);
+								}).set('goon', get.damageEffect(target, player, player, 'fire') > 0 && get.attitude(player, target) <= 0).forResult();
-								if(result.bool){
-									player.logSkill('dcxiaoyin_damage',source);
-									source.line(target,'fire');
-									source.discard(result.cards).discarder=source;
-									game.delayex();
-									target.loseToDiscardpile(cards);
-									trigger.addNumber('num',1);
-								}
 							}
 							else {
-								var result=yield source.chooseBool(`###是否响应${get.translation(player)}的【硝引】？###获得${get.translation(target)}的“硝引”牌（${get.translation(cards)}），然后将你对其造成的此次伤害改为火焰伤害。`).set('choice',(()=>{
+								event.result = await source.chooseBool(`###是否响应${get.translation(player)}的【硝引】？###获得${get.translation(target)}的一张“硝引”牌（${get.translation(cards)}），然后将你对其造成的此次伤害改为火焰伤害。`).set('choice', (() => {
 									if (get.damageEffect(target, source, source, 'fire') < get.damageEffect(target, source, source) - 5) return false;
 									if (cards.map(i => get.value(i)).reduce((p, c) => p + c, 0) > 0) return true;
 									return false;
-								})());
+								})()).forResult();
-								if(result.bool){
-									player.logSkill('dcxiaoyin_damage',source);
-									source.line(target,'fire');
-									source.gain(cards,target,'give');
-									game.setNature(trigger,'fire');
 							}
+						},
+						async content(event, trigger, player){
+							const source = trigger.source, target = trigger.player;
+							if (trigger.hasNature('fire')) {
+								source.line(target, 'fire');
+								const type = get.type2(event.cards[0]);
+								await source.discard(event.cards).set('discarder', source);
+								//await game.asyncDelayx();
+								const cardsToDiscard = target.getExpansions('dcxiaoyin').filter(card => get.type2(card, false) === type);
+								if (cardsToDiscard.length === 1) await target.loseToDiscardpile(cardsToDiscard);
+								else if (cardsToDiscard.length > 1) {
+									const result = await source.chooseButton([
+										`请选择移去${get.translation(source)}的一张“硝引”牌`,
+										cardsToDiscard
+									], true).forResult();
+									await target.loseToDiscardpile(result.links);
+								}
+								trigger.addNumber('num', 1);
+							}
+							else {
+								source.line(target, 'fire');
+								const cards = target.getExpansions('dcxiaoyin');
+								if (cards.length === 1) await source.gain(cards, target, 'give');
+								else if (cards.length > 1) {
+									const result = await source.chooseButton([
+										`请选择获得${get.translation(source)}的一张“硝引”牌`,
+										cards
+									], true).forResult();
+									await source.gain(result.links, target, 'give');
+								}
+								game.setNature(trigger, 'fire');
 							}
 						},
 					},
@@ -14315,6 +14842,43 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			},
 		},
 		card:{
+			//武关羽的兵临城下水淹七军
+			shuiyanqijuny:{
+				audio:'shuiyanqijun',
+				fullskin:true,
+				cardimage:'shuiyanqijunx',
+				enable:true,
+				filterTarget:true,
+				type:'trick',
+				selectTarget:[1,2],
+				targetprompt:['受伤弃牌','受伤摸牌'],
+				contentBefore(){
+					var evt=event.getParent(),target=evt.stocktargets[0];
+					evt.shuiyanqijun_target=target;
+				},
+				content(){
+					target.damage('thunder');
+					if(target!=event.getParent().shuiyanqijun_target) target.draw();
+					else target.chooseToDiscard('he',true);
+				},
+				ai:{
+					order:6,
+					value:4,
+					useful:2,
+					tag:{
+						damage:1,
+						thunderDamage:1,
+						natureDamage:1,
+						loseCard:1,
+					},
+					result:{
+						target:function(player,target){
+							if(!ui.selected.targets.length) return -1.5;
+							return -0.5
+						}
+					}
+				}
+			},
 			pyzhuren_heart:{
 				fullskin:true,
 				derivation:'puyuan',
@@ -14628,6 +15192,8 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			dingshangwan:['dingshangwan','ol_dingshangwan'],
 			qinghegongzhu:['qinghegongzhu','dc_qinghegongzhu'],
 			caofang:['caofang','jsrg_caofang'],
+			caomao:['caomao','mb_caomao'],
+			sp_zhenji:['sp_zhenji','jsrg_zhenji'],
 		},
 		translate:{
 			puyuan:'蒲元',
@@ -14805,7 +15371,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			zhushi_info:'主公技。每回合限一次，其他魏势力角色于回合内回复体力时，其可令你摸一张牌。',
 			laiyinger:'来莺儿',
 			xiaowu:'绡舞',
-			xiaowu_info:'出牌阶段限一次，你可以选择任意名座位连续且包含你的上家/下家的角色。这些角色依次选择一项：⒈令你摸一张牌；⒉其摸一张牌。然后若选择选项一的角色数大于选项二的角色数，则你获得一枚“沙”；若选择选项二的角色数大于选项一的角色数，则你对这些角色依次造成1点伤害。',
+			xiaowu_info:'出牌阶段限一次，你可以选择任意名座位连续且包含你的上家/下家的其他角色。这些角色依次选择一项：⒈令你摸一张牌；⒉其摸一张牌。然后若选择选项一的角色数大于选项二的角色数，则你获得一枚“沙”；若选择选项二的角色数大于选项一的角色数，则你对这些角色依次造成1点伤害。',
 			huaping:'化萍',
 			huaping_info:'限定技。①一名其他角色死亡时，你可获得其当前拥有的所有不带有「Charlotte」标签的技能，然后你失去〖绡舞〗，移去所有“沙”并摸等量的牌。②当你死亡时，你可令一名其他角色获得〖沙舞〗和你的所有“沙”。',
 			shawu:'沙舞',
@@ -14915,7 +15481,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			dcmengchi:'蒙斥',
 			dcmengchi_info:'锁定技。若你未于当前回合得到过牌：你不能使用牌；当你横置前，取消之；当你受到无属性伤害后，回复1点体力。',
 			dcfangdu:'芳妒',
-			dcfangdu_info:'锁定技。当你于回合外受到伤害后，若此次伤害为你于本回合受到的：第一次无属性伤害，你回复1点体力；第一次属性伤害，你随机获得伤害来源的一张牌。',
+			dcfangdu_info:'锁定技。当你于回合外受到伤害后，若此次伤害为你于本回合受到的：第一次无属性伤害，你回复1点体力；第一次属性伤害，你随机获得伤害来源的一张手牌。',
 			dcjiexing:'节行',
 			dcjiexing_info:'当你受到伤害后、失去体力后或回复体力后，你可以摸一张牌，且此牌不计入本回合的手牌上限。',
 			dongguiren:'董贵人',
@@ -15109,7 +15675,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			dclima:'骊马',
 			dclima_info:'锁定技。你计算至其他角色的距离-X（X为场上的坐骑牌数且至少为1）。',
 			dcxiaoyin:'硝引',
-			dcxiaoyin_info:'①准备阶段，你可以亮出牌堆顶的Y张牌（Y为你距离1以内的角色数），获得其中的红色牌，将其中任意张黑色牌置于等量名座次连续的其他角色的武将牌上，称为“硝引”。②当一名有“硝引”牌的角色受到伤害时，若此伤害为：火焰伤害，来源可以弃置一张其“硝引”牌包含的类型的牌，将其“硝引”置入弃牌堆，令此伤害+1；非火焰伤害，来源可以获得其“硝引”牌，将此伤害改为火焰伤害。',
+			dcxiaoyin_info:'①准备阶段，你可以亮出牌堆顶的Y张牌（Y为你距离1以内的角色数），获得其中的红色牌，将其中任意张黑色牌置于等量名座次连续的其他角色的武将牌上，称为“硝引”。②当一名有“硝引”牌的角色受到伤害时，若此伤害为：火焰伤害，来源可以弃置其“硝引”牌包含的类型的牌，将一张对应的“硝引”置入弃牌堆，令此伤害+1；非火焰伤害，来源可以获得一张“硝引”牌，将此伤害改为火焰伤害。',
 			dchuahuo:'花火',
 			dchuahuo_info:'出牌阶段限一次。你可以将一张红色手牌当不计入次数的火【杀】使用。然后当你使用此牌指定第一个目标后，若目标角色有“硝引”牌，你可以将此【杀】的目标改为所有有“硝引”牌的角色。',
 			caoyi:'曹轶',
@@ -15138,7 +15704,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			dcsbronghuo:'融火',
 			dcsbronghuo_info:'锁定技，当你使用火【杀】或【火攻】时，此牌伤害基值改为场上势力数。',
 			dcsbyingmou:'英谋',
-			dcsbyingmou_info:'转换技，每回合限一次，当你使用牌指定第一个目标后，你可以选择一名目标角色：阴，你将手牌数摸至与其相同（至多摸五张），然后视为对其使用一张【火攻】；阳，令一名手牌数为全场最大的角色对其使用手牌中所有的【杀】和伤害类锦囊牌（若其没有可使用的牌则将手牌数弃至与你相同）。',
+			dcsbyingmou_info:'转换技，每回合限一次，当你使用牌指定其他角色为目标后，你可以选择一名目标角色：阴，你将手牌数摸至与其相同（至多摸五张），然后视为对其使用一张【火攻】；阳，令一名手牌数为全场最大的角色对其使用手牌中所有的【杀】和伤害类锦囊牌（若其没有可使用的牌则将手牌数弃至与你相同）。',
 			caoxian:'曹宪',
 			dclingxi:'灵犀',
 			dclingxi_info:'出牌阶段开始和结束时，你可以将至多X张牌称为“翼”置于你的武将牌上（X为你的体力上限）。当你失去武将牌上的“翼”时，你将手牌数调整至Y张（Y为你武将牌上的“翼”所含有的花色数的两倍）。',
@@ -15192,6 +15758,23 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			dczhimin_info:'锁定技。①一轮游戏开始时，你选择至多X名其他角色（X为你的体力值），获得这些角色各自手牌中的随机一张点数最小的牌。②当你于你的回合外得到牌后，你将这些牌标记为“民”。③当你失去“民”后，你将手牌补至体力上限。',
 			dcjujian:'拒谏',	
 			dcjujian_info:'主公技。出牌阶段限一次，你可以令一名其他魏势力角色摸一张牌，然后你令其于本轮内使用的普通锦囊牌对你无效。',
+			wu_guanyu:'武关羽',
+			wu_guanyu_prefix:'武',
+			dcjuewu:'绝武',
+			dcjuewu_two:'2点',
+			dcjuewu_info:'①每回合每种牌名限一次。你可以将一张点数为2的牌当任意伤害类牌使用（包括【水淹七军】）。②当你得到其他角色区域内的牌后，你令这些牌的点数均视为2直到你失去这些牌。',
+			dcwuyou:'武佑',
+			dcwuyou_info:'①出牌阶段限一次。你可以选择一张手牌，从系统随机生成的五个非装备牌牌名中选择一个，令此牌的牌名与属性视为与你选择的相同。②其他角色的出牌阶段限一次。其可以交给你一张手牌，你从系统随机生成的五个非装备牌牌名中选择一个，然后交给其一张手牌，令此牌的牌名与属性视为与你选择的相同（一名角色使用〖武佑〗转化的牌无距离且无任何次数限制）。',
+			dcyixian:'义贤',
+			dcyixian_info:'限定技。出牌阶段，你可以选择一项：⒈获得场上的所有装备牌；⒉获得弃牌堆中的所有装备牌。然后你依次选择是否令被你以此法获得牌的角色摸X张牌并回复1点体力（X为其以此法失去的牌数）。',
+			shuiyanqijuny:'水淹七军',
+			shuiyanqijuny_info:'出牌阶段，对至多两名角色使用。目标角色受到1点雷属性伤害，然后若其：是此牌的使用者选择的第一个目标，其弃置一张牌；不是第一个目标，其摸一张牌。',
+			sp_zhenji:'SP甄宓',
+			sp_zhenji_prefix:'SP',
+			dcjijie:'己诫',
+			dcjijie_info:'锁定技。每回合限一次，当其他角色于其回合外得到牌后/回复体力后，你摸等量的牌/回复等量的体力。',
+			dchuiji:'惠济',
+			dchuiji_info:'出牌阶段限一次。你可以令一名角色摸两张牌或从牌堆中随机使用一张不为赠物的装备牌，然后若其手牌数不小于存活角色数，其视为使用一张【五谷丰登】。系统不于此牌使用准备工作结束时执行亮出牌堆顶的牌的动作，改为你令其将所有手牌置于处理区，然后令所有目标角色依次获得其中一张牌。当这些牌因执行【五谷丰登】的执行动作而置于弃牌堆后，你令其获得这些牌。',
 
 			sp2_yinyu:'隐山之玉',
 			sp2_huben:'百战虎贲',

character/yijiang.js

@@ -806,6 +806,9 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 						player.addExpose(0.1);
 					}
 				},
+				ai:{
+					combo:'duwang'
+				},
 				subSkill:{
 					fullyReady:{
 						trigger:{global:'phaseEnd'},
@@ -10956,6 +10959,9 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					"step 1"
 					player.loseMaxHp();
 					player.addSkills('paiyi');
+				},
+				ai:{
+					combo:'quanji'
 				}
 			},
 			paiyi:{

character/yingbian.js

@@ -3795,7 +3795,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			huishi:'慧识',
 			huishi_info:'摸牌阶段，你可以放弃摸牌，改为观看牌堆顶的X张牌，获得其中的一半（向下取整），然后将其余牌置入牌堆底。（X为牌堆数量的个位数）',
 			qingleng:'清冷',
-			qingleng_info:'一名角色的回合结束时，若其体力值与手牌数之和不小于X，则你可将一张牌当无距离限制的冰属性【杀】对其使用（X为牌堆数量的个位数）。若这是你本局游戏内首次其发动过此技能，则你摸一张牌。',
+			qingleng_info:'一名角色的回合结束时，若其体力值与手牌数之和不小于X，则你可将一张牌当无距离限制的冰属性【杀】对其使用（X为牌堆数量的个位数）。若这是你本局游戏内首次对其发动此技能，则你摸一张牌。',
 			xuanmu:'宣穆',
 			xuanmu2:'宣穆',
 			xuanmu_info:'锁定技，隐匿技。你于其他角色的回合登场时，防止你受到的伤害直到回合结束。',
@@ -3849,7 +3849,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 			jin_xiahouhui:'晋夏侯徽',
 			jin_xiahouhui_prefix:'晋',
 			baoqie:'宝箧',
-			baoqie_info:'隐匿技，锁定技。你登场后，从牌堆中获得一张不为赠物的宝物牌。若此牌在你的手牌区内为宝物牌，则你可以使用此牌。',
+			baoqie_info:'隐匿技，锁定技。你登场后，从牌堆或弃牌堆中获得一张不为赠物的宝物牌。若此牌在你的手牌区内为宝物牌，则你可以使用此牌。',
 			jyishi:'宜室',
 			jyishi_info:'每回合限一次，当有其他角色于其出牌阶段内因弃置而失去手牌后，你可令其获得这些牌中位于弃牌堆的一张，然后你获得其余位于弃牌堆的牌。',
 			shiduo:'识度',

game/package.js

@@ -35,13 +35,13 @@ window.noname_package={
 	card:{
 		standard:'标准',
 		extra:'军争',
-		sp:'忠胆英杰',
 		guozhan:'国战',
-		zhulu:'逐鹿天下',
 		yingbian:'应变篇',
 		yongjian:'用间篇',
-		zhenfa:'阵法',
+		sp:'忠胆英杰',
+		zhulu:'逐鹿天下',
 		yunchou:'运筹帷幄',
+		zhenfa:'阵法',
 		swd:'轩辕剑',
 		gujian:'古剑奇谭',
 		hearth:'炉石传说',

game/pinyinjs.js

@@ -66,6 +66,7 @@ var pinyin_dict_polyphone = {
 	"库特莉亚芙卡": "     kǎ",
 	"露娜": "lù ",
 	// 技能名
+	"弹雀": "tán què",
 	"重身": "chóng ",
 	"畜鸣": "chù ",
 	"聆乐": " yuè",

mode/doudizhu.js

@@ -1851,8 +1851,6 @@ game.import('mode',function(lib,game,ui,get,ai,_status){
 			binglin_neihong_info:'锁定技，当你杀死队友后，你所在的阵营视为游戏失败。',
 			baiyidujiang:'白衣渡江',
 			baiyidujiang_info:'出牌阶段，对地主使用。你选择一项：①令其将手牌数摸至全场最多。②令其将手牌数弃置至全场最少。',
-			shuiyanqijuny:'水淹七军',
-			shuiyanqijuny_info:'出牌阶段，对至多两名角色使用。目标角色受到1点雷属性伤害，然后若其：是此牌的使用者选择的第一个目标，其弃置一张牌；不是第一个目标，其摸一张牌。',
 			luojingxiashi:'落井下石',
 			luojingxiashi_info:'出牌阶段，对所有其他的已受伤角色使用。目标角色受到1点伤害。',
 			binglinchengxia:'兵临城下',
@@ -2787,41 +2785,6 @@ game.import('mode',function(lib,game,ui,get,ai,_status){
 					}
 				}
 			},
-			shuiyanqijuny:{
-				fullskin:true,
-				cardimage:'shuiyanqijunx',
-				enable:true,
-				filterTarget:true,
-				type:'trick',
-				selectTarget:[1,2],
-				targetprompt:['受伤弃牌','受伤摸牌'],
-				contentBefore:function(){
-					var evt=event.getParent(),target=evt.stocktargets[0];
-					evt.shuiyanqijun_target=target;
-				},
-				content:function(){
-					target.damage('thunder');
-					if(target!=event.getParent().shuiyanqijun_target) target.draw();
-					else target.chooseToDiscard('he',true);
-				},
-				ai:{
-					order:6,
-					value:4,
-					useful:2,
-					tag:{
-						damage:1,
-						thunderDamage:1,
-						natureDamage:1,
-						loseCard:1,
-					},
-					result:{
-						target:function(player,target){
-							if(!ui.selected.targets.length) return -1.5;
-							return -0.5
-						}
-					}
-				}
-			},
 			luojingxiashi:{
 				fullskin:true,
 				enable:true,

mode/guozhan.js

@@ -518,7 +518,7 @@ game.import('mode',function(lib,game,ui,get,ai,_status){
 				gz_zoushi:['female','qun',3,['huoshui','new_qingcheng']],
 
 				gz_dengai:['male','wei',4,['tuntian','ziliang','gzjixi'],['gzskin','die_audio']],
-				gz_caohong:['male','wei',4,['gzhuyuan','heyi'],['gzskin']],
+				gz_caohong:['male','wei',4,['fakehuyuan','heyi'],['gzskin']],
 				gz_jiangfei:['male','shu',3,['shengxi','gzshoucheng']],
 				gz_jiangwei:['male','shu',4,['tiaoxin','yizhi','tianfu'],['gzskin']],
 				gz_xusheng:['male','wu',4,['fakeyicheng'],['gzskin']],
@@ -569,7 +569,7 @@ game.import('mode',function(lib,game,ui,get,ai,_status){
 				gz_wangping:['male','shu',4,['jianglue'],['gzskin']],
 				gz_fazheng:['male','shu',3,['gzxuanhuo','gzenyuan'],['gzskin']],
 				gz_wuguotai:['female','wu',3,['gzbuyi','ganlu'],['gzskin']],
-				gz_lukang:['male','wu',4,['fakejueyan','keshou'],['gzskin']],
+				gz_lukang:['male','wu',4,['fakejueyan','fakekeshou'],['gzskin']],
 				gz_yuanshu:['male','qun',4,['gzweidi','gzyongsi'],['gzskin']],
 				gz_zhangxiu:['male','qun',4,['gzfudi','gzcongjian'],['gzskin']],
 				gz_jun_caocao:['male','wei',4,['jianan','huibian','gzzongyu','wuziliangjiangdao'],[]],
@@ -1449,7 +1449,6 @@ game.import('mode',function(lib,game,ui,get,ai,_status){
 						}
 						if(goon){
 							event.tochange.push(_status.characterlist[i]);
-							if(event.tochange.length==event.num) break;
 						}
 					}
 					event.tochange=event.tochange.filter(character=>{
@@ -1457,7 +1456,7 @@ game.import('mode',function(lib,game,ui,get,ai,_status){
 						const doublex=get.is.double(character,true);
 						const group=(doublex?doublex:[get.character(character,1)]);
 						return !group.some(j=>groups.includes(j));
-					});
+					}).randomGets(event.num);
 					if(!event.tochange.length) event.finish();
 					else{
 						if(event.tochange.length==1) event._result={
@@ -2115,13 +2114,36 @@ game.import('mode',function(lib,game,ui,get,ai,_status){
 					},'he');
 				},
 				filterCard(card,player){
+					if(!lib.suit.includes(get.suit(card))) return false;
 					return lib.filter.cardDiscardable(card,player)&&!player.getStorage('fakezhufu_effect').includes(get.suit(card));
 				},
 				position:'he',
 				check(card){
 					const player=get.event('player');
-					if(player.hasUseTarget(card,true,true)) return 0;
+					let cards=player.getCards('hs',card=>player.hasValueTarget(card,true,true));
-					return 5+3*Math.random()-get.value(card);
+					let discards=player.getCards('he',card=>get.info('fakezhufu').filterCard(card,player));
+					for(let i=1;i<discards.length;i++){
+						if(discards.slice(0,i).some(card=>get.suit(card)==get.suit(discards[i]))) discards.splice(i--,1);
+					}
+					cards.removeArray(discards);
+					if(!cards.length||!discards.length) return 0;
+					cards.sort((a,b)=>{
+						return (player.getUseValue(b,true,true)>0?get.order(b):0)-(player.getUseValue(a,true,true)>0?get.order(a):0);
+					});
+					const cardx=cards[0];
+					if(get.order(cardx,player)>0&&discards.includes(card)){
+						if((get.suit(card)=='heart'&&get.type(cardx)!='equip'&&(function(card,player){
+							const num=get.info('fakezhufu').getMaxUseTarget(card,player);
+							return num!=-1&&game.countPlayer(target=>player.canUse(card,target,true,true)&&get.effect(target,card,player,player)>0)>num;
+						}(cardx,player))&&game.hasPlayer(target=>{
+							return target.isFriendOf(player)&&target.hasCard(cardy=>{
+								return lib.filter.cardDiscardable(cardy,target)&&get.type2(cardy)==get.type2(cardx);
+							},'h');
+						}))||(get.suit(card)=='diamond'&&get.type(cardx)!='equip'&&!game.hasPlayer(target=>{
+							return target.countCards('h')>player.countCards('h')-(get.position(card)=='h'?1:0)-(get.position(cardx)=='h'?1:0);
+						}))||(get.suit(card)=='spade'&&player.getHp()==1)||(get.suit(card)=='club'&&get.tag(cardx,'damage')&&player.countCards('h')-(get.position(card)=='h'?1:0)-(get.position(cardx)=='h'?1:0)==0)) return 1/(getvalue(card)||0.5);
+					}
+					return 0;
 				},
 				async content(event,trigger,player){
 					const suit=get.suit(event.cards[0],player);
@@ -2129,8 +2151,74 @@ game.import('mode',function(lib,game,ui,get,ai,_status){
 					player.markAuto('fakezhufu_effect',[[suit,false]]);
 				},
 				ai:{
-					order:7,
+					order(item,player){
-					result:{player:1},
+						let cards=player.getCards('hs',card=>player.hasValueTarget(card,true,true));
+						let discards=player.getCards('he',card=>get.info('fakezhufu').filterCard(card,player));
+						for(let i=1;i<discards.length;i++){
+							if(discards.slice(0,i).some(card=>get.suit(card)==get.suit(discards[i]))) discards.splice(i--,1);
+						}
+						cards.removeArray(discards);
+						if(!cards.length||!discards.length) return 0;
+						cards.sort((a,b)=>{
+							return (player.getUseValue(b,true,true)>0?get.order(b):0)-(player.getUseValue(a,true,true)>0?get.order(a):0);
+						});
+						const cardx=cards[0];
+						return (get.order(cardx,player)>0&&((discards.some(card=>{
+							return get.suit(card)=='heart';
+						})&&get.type(cardx)!='equip'&&(function(card,player){
+							const num=get.info('fakezhufu').getMaxUseTarget(card,player);
+							return num!=-1&&game.countPlayer(target=>player.canUse(card,target,true,true)&&get.effect(target,card,player,player)>0)>num;
+						}(cardx,player))&&game.hasPlayer(target=>{
+							return target.isFriendOf(player)&&target.hasCard(cardy=>{
+								return lib.filter.cardDiscardable(cardy,target)&&get.type2(cardy)==get.type2(cardx);
+							},'h');
+						}))||(get.type(cardx)!='equip'&&discards.some(card=>{
+							return get.suit(card)=='diamond'&&!game.hasPlayer(target=>{
+								return target.countCards('h')>player.countCards('h')-(get.position(card)=='h'?1:0)-(get.position(cardx)=='h'?1:0);
+							});
+						}))||(discards.some(card=>{
+							return get.suit(card)=='spade';
+						})&&player.getHp()==1)||(get.tag(cardx,'damage')&&discards.some(card=>{
+							return get.suit(card)=='club'&&player.countCards('h')-(get.position(card)=='h'?1:0)-(get.position(cardx)=='h'?1:0)==0;
+						}))))?(get.order(cardx,player)+0.00001):0;
+					},
+					result:{
+						player(player,target){
+							let cards=player.getCards('hs',card=>player.hasValueTarget(card,true,true));
+							let discards=player.getCards('he',card=>get.info('fakezhufu').filterCard(card,player));
+							discards=discards.sort((a,b)=>get.value(a)-get.value(b));
+							for(let i=1;i<discards.length;i++){
+								if(discards.slice(0,i).some(card=>get.suit(card)==get.suit(discards[i]))) discards.splice(i--,1);
+							}
+							cards.removeArray(discards);
+							if(!cards.length||!discards.length) return 0;
+							if((discards.some(card=>{
+								return get.suit(card)=='heart';
+							})&&cards.some(card=>{
+								return get.type(card)!='equip'&&(function(card,player){
+									const num=get.info('fakezhufu').getMaxUseTarget(card,player);
+									return num!=-1&&game.countPlayer(target=>player.canUse(card,target,true,true)&&get.effect(target,card,player,player)>0)>num;
+								}(card,player))&&game.hasPlayer(target=>{
+									return target.isFriendOf(player)&&target.hasCard(cardx=>{
+										return lib.filter.cardDiscardable(cardx,target)&&get.type2(cardx)==get.type2(card);
+									},'h');
+								});
+							}))||discards.some(card=>{
+								return get.suit(card)=='diamond'&&cards.some(cardx=>{
+									return get.type(cardx)!='equip'&&!game.hasPlayer(target=>{
+										return target.countCards('h')>player.countCards('h')-(get.position(card)=='h'?1:0)-(get.position(cardx)=='h'?1:0);
+									});
+								});
+							})||(discards.some(card=>{
+								return get.suit(card)=='spade';
+							})&&player.getHp()==1)||discards.some(card=>{
+								return get.suit(card)=='club'&&cards.some(cardx=>{
+									return get.tag(cardx,'damage')&&player.countCards('h')-(get.position(card)=='h'?1:0)-(get.position(cardx)=='h'?1:0)==0;
+								});
+							})) return 1;
+							return 0;
+						},
+					},
 				},
 				subSkill:{
 					effect:{
@@ -2144,7 +2232,7 @@ game.import('mode',function(lib,game,ui,get,ai,_status){
 								let str='';
 								str+='<li>已弃置过的花色：';
 								str+=suits;
-								if(used.length){
+								if(usedSuits.length){
 									str+='<br><li>已触发过的花色：';
 									str+=usedSuits;
 								}
@@ -2157,22 +2245,67 @@ game.import('mode',function(lib,game,ui,get,ai,_status){
 							return player.getStorage('fakezhufu_effect').some(list=>!list[1]);
 						},
 						forced:true,
-						content(){
+						firstDo:true,
-							if(!Array.isArray(trigger.temporaryYingbian)) trigger.temporaryYingbian=[];
+						async content(event,trigger,player){
-							trigger.forceYingbian=true
+							const list=player.getStorage('fakezhufu_effect').filter(i=>!i[1]);
-							trigger.temporaryYingbian.addArray(player.getStorage('fakezhufu_effect').filter(list=>{
+							const forced=(function(trigger,player){
-								return !list[1];
+								if(trigger.forceYingbian||player.hasSkillTag('forceYingbian')) return true;
-							}).map(list=>{
+								const list=(trigger.temporaryYingbian||[]);
-								return get.info('fakezhufu').YingBianMap[list[0]];
+								return list.includes('force')||get.cardtag(trigger.card,'yingbian_force');
-							}));
+							}(trigger,player));
+							if(forced){
+								player.popup('yingbian_force_tag',lib.yingbian.condition.color.get('force'));
+								game.log(player,'触发了','#g【注傅】','为',trigger.card,'添加的应变条件');
+							}
+							const hasYingBian=(trigger.temporaryYingbian||[]),map=get.info('fakezhufu').YingBianMap;
+							for(const j of list){
+								player.storage.fakezhufu_effect[player.getStorage('fakezhufu_effect').indexOf(j)][1]=true;
+								const tag=map[j[0]][0],eff=map[j[0]][1];
+								if(get.cardtag(trigger.card,`yingbian_${tag}`)) continue;
+								if(j[0]=='heart'){
+									if(!forced&&!hasYingBian.includes('add')){
+										const {result}=await lib.yingbian.condition.complex.get('zhuzhan')(trigger);
+										if(result.bool){
+											game.log(player,'触发了','#g【注傅】','为',trigger.card,'添加的应变条件（','#g'+get.translation(j[0]),'）');
+											trigger.yingbian_addTarget=true;
+											player.addTempSkill('yingbian_changeTarget');
+										}
+									}
+									else{
+										if(!forced){
+											game.log(player,'触发了','#g【注傅】','为',trigger.card,'添加的应变条件（','#g'+get.translation(j[0]),'）');
+										}
+										trigger.yingbian_addTarget=true;
+										player.addTempSkill('yingbian_changeTarget');
+									}
+								}
+								else{
+									const goon=(hasYingBian.includes(eff)||lib.yingbian.condition.simple.get(tag)(trigger));
+									if(!forced&&goon){
+										player.popup('yingbian_force_tag',lib.yingbian.condition.color.get(eff));
+										game.log(player,'触发了','#g【注傅】','为',trigger.card,'添加的应变条件（','#g'+get.translation(j[0]),'）');
+									}
+									if(forced||goon) await game.yingbianEffect(trigger,lib.yingbian.effect.get(eff));
+								}
+							}
 						},
 					},
 				},
 				YingBianMap:{
-					'heart':'yingbian_zhuzhan',
+					'heart':['zhuzhan','add'],
-					'diamond':'yingbian_fujia',
+					'diamond':['fujia','hit'],
-					'spade':'yingbian_canqu',
+					'spade':['canqu','draw'],
-					'club':'yingbian_kongchao',
+					'club':['kongchao','damage'],
+				},
+				getMaxUseTarget(card,player){
+					let range;
+					const select=get.copy(get.info(card).selectTarget);
+					if(select==undefined) range=[1,1];
+					else if(typeof select=='number') range=[select,select];
+					else if(get.itemtype(select)=='select') range=select;
+					else if(typeof select=='function') range=select(card,player);
+					game.checkMod(card,player,range,'selectTarget',player);
+					return range;
 				},
 			},
 			fakeguishu:{
@@ -2329,7 +2462,7 @@ game.import('mode',function(lib,game,ui,get,ai,_status){
 			fakeqizhi:{
 				audio:'qizhi',
 				inherit:'qizhi',
-				trigger:{player:'useCard'},
+				trigger:{player:'useCard1'},
 				filter(event,player){
 					if(!event.targets||!event.targets.length) return false;
 					if(_status.currentPhase!=player) return false;
@@ -2350,11 +2483,10 @@ game.import('mode',function(lib,game,ui,get,ai,_status){
 				async content(event,trigger,player){
 					const target=event.targets[0];
 					const {result:{bool,cards}}=await player.discardPlayerCard(target,'he',true);
-					if(get.is.yingbianConditional(trigger.card)&&bool){
+					if(bool){
+						await target.draw();
 						if(cards.some(i=>get.suit(i,target)==get.suit(trigger.card))){
-							player.when('yingbian')
+							trigger.forceYingbian=true;
-							.filter(evt=>evt.card==trigger.card)
-							.then(()=>trigger.forceYingbian=true);
 						}
 					}
 				},
@@ -3312,7 +3444,7 @@ game.import('mode',function(lib,game,ui,get,ai,_status){
 					},event).indexOf(event)==0;
 				},
 				async cost(event,trigger,player){
-					event.result=await player.chooseTarget(get.prompt('fakebaoqie'),'获得一名角色的宝物牌，然后你可以使用此牌',(card,player,target)=>{
+					event.result=await player.chooseTarget(get.prompt('fakebaoqie'),'获得一名角色装备区里所有的宝物牌，然后你可以使用其中的一张牌',(card,player,target)=>{
 						return target.getGainableCards(player,'e').some(card=>get.subtype(card)=='equip5');
 					}).set('ai',target=>{
 						const player=get.event('player');
@@ -3327,10 +3459,10 @@ game.import('mode',function(lib,game,ui,get,ai,_status){
 					await player.gain(cards,target,'giveAuto');
 					cards=cards.filter(i=>get.owner(i)==player&&get.position(i)=='h'&&player.hasUseTarget(i));
 					if(cards.length){
-						const {result:{bool,links}}=await player.chooseButton(['宝箧：是否使用其中一张宝物牌？',cards]).set('ai',button=>{
+						const {result:{bool,links}}=await player.chooseButton(['宝箧：是否使用其中的一张宝物牌？',cards]).set('ai',button=>{
 							return get.equipValue(button.link,get.event('player'));
 						});
-						if(bool) await player.chooseUseTarget(card,true);
+						if(bool) await player.chooseUseTarget(links[0],true);
 					}
 				},
 				ai:{mingzhi_no:true},
@@ -4046,6 +4178,116 @@ game.import('mode',function(lib,game,ui,get,ai,_status){
 					},
 				},
 			},
+			fakehuyuan:{
+				audio:'yuanhu',
+				trigger:{player:'phaseJieshuBegin'},
+				filter(event,player){
+					return player.countCards('he',card=>{
+						if(get.position(card)=='h'&&_status.connectMode) return true;
+						return get.type(card)=='equip';
+					})>0;
+				},
+				async cost(event,trigger,player){
+					event.result=await player.chooseCardTarget({
+						prompt:get.prompt2('yuanhu'),
+						filterCard(card){
+							return get.type(card)=='equip';
+						},
+						position:'he',
+						filterTarget(card,player,target){
+							return target.canEquip(card);
+						},
+						ai1(card){
+							return 6-get.value(card);
+						},
+						ai2(target){
+							return get.attitude(_status.event.player,target)-3;
+						},
+					}).set('hiddenSkill','fakehuyuan').forResult();
+				},
+				preHidden:true,
+				async content(event,trigger,player){
+					const card=event.cards[0],target=event.targets[0];
+					if(target!=player) player.$give(card,target,false);
+					await target.equip(card);
+				},
+				group:'fakehuyuan_discard',
+				subSkill:{
+					discard:{
+						trigger:{global:'equipEnd'},
+						filter(event,player){
+							return _status.currentPhase==player&&game.hasPlayer(target=>{
+								return get.distance(event.player,target)<=1&&target!=event.player&&target.countCards('hej');
+							});
+						},
+						async cost(event,trigger,player){
+							event.result=await player.chooseTarget(get.prompt('fakehuyuan'),'弃置一名与'+get.translation(trigger.player)+'距离为1以内的另一名角色区域里的一张牌',(card,player,target)=>{
+								const trigger=get.event().getTrigger();
+								return get.distance(trigger.player,target)<=1&&target!=trigger.player&&target.countCards('hej');
+							}).set('ai',target=>{
+								const player=get.event('player');
+								return get.effect(target,{name:'guohe'},player,player);
+							}).set('hiddenSkill','fakehuyuan').forResult();
+						},
+						popup:false,
+						async content(event,trigger,player){
+							const target=event.targets[0];
+							player.logSkill('fakehuyuan',target);
+							await player.discardPlayerCard(target,'hej',true);
+						},
+					},
+				},
+			},
+			fakekeshou:{
+				audio:'keshou',
+				trigger:{player:'damageBegin3'},
+				filter(event,player){
+					return event.num>0;
+				},
+				preHidden:true,
+				async cost(event,trigger,player){
+					event.result=await player.chooseToDiscard(get.prompt('fakekeshou'),'弃置两张颜色相同的牌，令即将受到的伤害-1','he',2,card=>{
+						return !ui.selected.cards.length||get.color(card)==get.color(ui.selected.cards[0]);
+					}).set('logSkill','fakekeshou').set('complexCard',true).setHiddenSkill('fakekeshou').set('ai',card=>{
+						if(!_status.event.check) return 0;
+						var player=_status.event.player;
+						if(player.hp==1){
+							if(!player.countCards('h',function(card){return get.tag(card,'save')})&&!player.hasSkillTag('save',true)) return 10-get.value(card);
+							return 7-get.value(card);
+						}
+						return 6-get.value(card);
+					}).set('check',(player.countCards('h',{color:'red'})>1||player.countCards('h',{color:'black'})>1)).forResult();
+				},
+				popup:false,
+				async content(event,trigger,player){
+					trigger.num--;
+				},
+				group:'fakekeshou_draw',
+				subSkill:{
+					draw:{
+						audio:'keshou',
+						trigger:{
+							player:'loseAfter',
+							global:'loseAsyncAfter',
+						},
+						filter(event,player){
+							if(event.type!='discard'||event.getlx===false) return false;
+							if(!(!player.isUnseen()&&!game.hasPlayer(current=>{
+								return current!=player&&current.isFriendOf(player);
+							}))) return false;
+							const evt=event.getl(player);
+							return evt&&evt.cards2&&evt.cards2.length>1;
+						},
+						prompt2:'进行一次判定，若为红色，则你摸一张牌',
+						async content(event,trigger,player){
+							const result=await player.judge(card=>{
+								return get.color(card)=='red'?1:0;
+							}).forResult();
+							if(result.judge>0) await player.draw();
+						},
+					},
+				},
+			},
 			//国战典藏2023补充
 			//吕范
 			gzdiaodu:{
@@ -14525,7 +14767,7 @@ return event.junling=='junling5'?1:0;});
 						if(content&&content.length){
 							dialog.addSmall(content);
 						}
-						dialog.addText('<ul style="margin-top:5px;padding-left:22px;"><li>每名吴势力角色的出牌阶段限一次，该角色可以将一张装备牌置于“缘江烽火图”上，称之为“烽火”。<li>根据“烽火”的数量，所有吴势力角色可于其准备阶段开始时选择并获得其中一个技能直到回合结束：一张以上~英姿；两张以上~好施；三张以上~涉猎；四张以上~度势；五张以上~可额外选择一项。<li>锁定技，当你受到【杀】或锦囊牌造成的伤害后，你将一张“烽火”置入弃牌堆。',false)
+						dialog.addText('<ul style="margin-top:5px;padding-left:22px;"><li>每名吴势力角色的出牌阶段限一次，该角色可以将一张装备牌置于“缘江烽火图”上，称之为“烽火”。<li>根据“烽火”的数量，所有吴势力角色可于其准备阶段选择并获得其中一个技能直到回合结束：一张以上~英姿；两张以上~好施；三张以上~涉猎；四张以上~度势；五张以上~可额外选择一项。<li>锁定技，当你受到【杀】或锦囊牌造成的伤害后，你将一张“烽火”置入弃牌堆。',false)
 					}
 				}
 			},
@@ -17867,7 +18109,7 @@ return event.junling=='junling5'?1:0;});
 			gzjiancai:'荐才',
 			gzjiancai_info:'副将技，此武将牌上单独的阴阳鱼个数-1。与你势力相同的角色即将受到伤害而进入濒死状态时，你可以防止此伤害，若如此做，你须变更副将；与你势力相同的角色变更副将时，其额外获得两张备选武将牌。',
 			gzzhuhai:'诛害',
-			gzzhuhai_info:'其他角色的结束阶段开始时，若其本回合内造成过伤害，则你可以对其使用一张【杀】（无距离限制）。若其本回合内对与你势力相同的角色造成过伤害，则此【杀】无视防具，且当其抵消此【杀】后，其须弃置一张牌。',
+			gzzhuhai_info:'其他角色的结束阶段，若其本回合内造成过伤害，则你可以对其使用一张【杀】（无距离限制）。若其本回合内对与你势力相同的角色造成过伤害，则此【杀】无视防具，且当其抵消此【杀】后，其须弃置一张牌。',
 			gzzhuosheng:'擢升',
 			gzzhuosheng2:'擢升',
 			gzzhuosheng_info:'当一名与你势力相同的角色受到伤害后，你可令其摸一张牌。然后直到其下个结束阶段前，其使用此牌根据类型执行以下效果：1. 基本牌，不计入次数且无距离限制；2. 普通锦囊牌，此牌目标可+1或-1；3. 装备牌，可摸一张牌。',
@@ -17879,7 +18121,7 @@ return event.junling=='junling5'?1:0;});
 			gzhuaiyi:'怀异',
 			gzhuaiyi_info:'出牌阶段限一次，你可以展示所有手牌。若其中包含两种颜色，则你可以弃置其中一种颜色的所有牌，然后获得至多等量名角色的各一张牌。然后你将以此法得到的装备牌置于武将牌上，称为“异”。',
 			gzzisui:'恣睢',
-			gzzisui_info:'锁定技，摸牌阶段，你多摸X张牌。结束阶段开始时，若X大于你的体力上限，你死亡（X为“异”数）。',
+			gzzisui_info:'锁定技，摸牌阶段，你多摸X张牌。结束阶段，若X大于你的体力上限，你死亡（X为“异”数）。',
 
 			gz_tangzi:'唐咨',
 			gz_mengda:'孟达',
@@ -17928,17 +18170,17 @@ return event.junling=='junling5'?1:0;});
 			gzjuejue:'决绝',
 			gzjuejue_info:'①弃牌阶段开始时，你可失去1点体力。然后若你于此阶段内弃置过你的牌，则你令其他角色各选择一项：1.将X张手牌置入弃牌堆（X为你于此阶段内弃置过的牌数）；2.受到你造成的1点伤害。②你杀死与你势力相同的角色不执行奖惩。',
 			gzfangyuan:'方圆',
-			gzfangyuan_info:'阵法技，若你在一个围攻关系中：①是围攻角色，则所有围攻角色的手牌上限+1且被围攻角色手牌上限-1；②是被围攻角色，则结束阶段开始时，你视为对一名围攻角色使用【杀】。',
+			gzfangyuan_info:'阵法技，若你在一个围攻关系中：①是围攻角色，则所有围攻角色的手牌上限+1且被围攻角色手牌上限-1；②是被围攻角色，则结束阶段，你视为对一名围攻角色使用【杀】。',
 			daming:'达命',
 			daming_info:'一名己方角色A的出牌阶段开始时，你可弃置一张锦囊牌，横置一名角色并摸X张牌（X为拥有横置角色的势力数）。然后你选择一项：①令A回复1点体力；②令A视为对由你选择的另一名角色使用一张雷【杀】。',
 			xiaoni:'嚣逆',
 			xiaoni_info:'锁定技，当你使用牌时，或成为其他角色使用牌的目标后，若场上存在其他己方角色且这些角色的手牌数均不大于你，则目标角色/你不可响应此牌。',
 			gztongduo:'统度',
-			gztongduo_info:'己方角色的结束阶段开始时，其可以摸X张牌（X为其本回合弃牌阶段弃置的牌数且至多为3）。',
+			gztongduo_info:'己方角色的结束阶段，其可以摸X张牌（X为其本回合弃牌阶段弃置的牌数且至多为3）。',
 			qingyin:'清隐',
 			qingyin_info:'限定技，出牌阶段，你可令所有己方角色将体力值回满，然后移除此武将牌。',
 			gzlianpian:'联翩',
-			gzlianpian_info:'①结束阶段开始时，若你于此回合内弃置过所有角色的牌数之和大于你的体力值，你可令一名与你势力相同的角色将手牌补至X张（X为其体力上限）。②其他角色的结束阶段开始时，若其于此回合内弃置过所有角色的牌数之和大于你的体力值，其可选择：1.弃置你的一张牌；2.令你回复1点体力。',
+			gzlianpian_info:'①结束阶段，若你于此回合内弃置过所有角色的牌数之和大于你的体力值，你可令一名与你势力相同的角色将手牌补至X张（X为其体力上限）。②其他角色的结束阶段，若其于此回合内弃置过所有角色的牌数之和大于你的体力值，其可选择：1.弃置你的一张牌；2.令你回复1点体力。',
 			gzyusui:'玉碎',
 			gzyusui_info:'当你成为其他势力的角色使用黑色牌的目标后，你可以失去1点体力，然后选择一项：①令其弃置X张手牌（X为其体力上限）；②令其失去Y点体力（Y为其的体力值减去你的体力值，不为正时不可选择）。',
 			gzboyan:'驳言',
@@ -17950,10 +18192,10 @@ return event.junling=='junling5'?1:0;});
 			gzduwu:'黩武',
 			gzduwu_info:'限定技，出牌阶段，你可以选择一个“军令”。你令攻击范围内所有的非己方角色选择是否执行。若有角色选择否，则你对其造成1点伤害且你摸一张牌。若有角色于此技能结算过程中进入濒死状态且存活，则你失去1点体力。',
 			gzxishe:'袭射',
-			gzxishe_info:'其他角色的准备阶段开始时，你可将装备区内的一张牌当做【杀】对其使用且可重复此流程。若你的体力值大于该角色，则此【杀】不可被响应。若该角色于此技能的结算流程中死亡，则你可以变更副将（不展示）。',
+			gzxishe_info:'其他角色的准备阶段，你可将装备区内的一张牌当做【杀】对其使用且可重复此流程。若你的体力值大于该角色，则此【杀】不可被响应。若该角色于此技能的结算流程中死亡，则你可以变更副将（不展示）。',
 			gzcongcha:'聪察',
 			gzcongcha2:'聪察',
-			gzcongcha_info:'①准备阶段开始时，你可以选择一名未确定势力的其他角色。当其于你的下回合开始前首次明置武将牌后，若其：与你势力相同，则你与其各摸两张牌；与你势力不同，则其失去1点体力。②摸牌阶段开始时，若场上所有角色均有明置的武将牌，则你可以令额定摸牌数+2。',
+			gzcongcha_info:'①准备阶段，你可以选择一名未确定势力的其他角色。当其于你的下回合开始前首次明置武将牌后，若其：与你势力相同，则你与其各摸两张牌；与你势力不同，则其失去1点体力。②摸牌阶段开始时，若场上所有角色均有明置的武将牌，则你可以令额定摸牌数+2。',
 			gzchenglve:'成略',
 			gzchenglve_info:'己方角色使用牌结算结束后，若此牌的目标数大于1，则你可以令其摸一张牌。若你受到过渠道为此牌的伤害，则你可以令一名没有国战标记的己方角色获得一枚“阴阳鱼”。',
 			gzbaolie:'豹烈',
@@ -17967,7 +18209,7 @@ return event.junling=='junling5'?1:0;});
 			qiuan_info:'当你受到伤害后，若此伤害的渠道有对应的实体牌且你的武将牌上没有“函”，则你可以防止此伤害并将这些牌置于你的武将牌上，称为“函”。',
 			liangfan:'量反',
 			liangfan2:'量反',
-			liangfan_info:'锁定技，准备阶段开始时，若你的武将牌上有“函”，则你获得这些牌，然后失去1点体力。当你于此回合内因使用实体牌中包含“函”的牌且执行这些牌的效果而对目标角色造成伤害时，你可以获得目标角色的一张牌。',
+			liangfan_info:'锁定技，准备阶段，若你的武将牌上有“函”，则你获得这些牌，然后失去1点体力。当你于此回合内因使用实体牌中包含“函”的牌且执行这些牌的效果而对目标角色造成伤害时，你可以获得目标角色的一张牌。',
 			gzwenji:'问计',
 			gzwenji_info:'出牌阶段开始时，你可令一名其他角色交给你一张牌。然后若该角色：未确定势力或势力与你相同，则你于本回合内使用实体牌包含“问计”牌的牌无距离和次数限制，且不可被其他角色响应。与你势力不同，则你交给其一张不为“问计”牌的牌或令其摸一张牌。',
 			gztunjiang:'屯江',
@@ -17981,9 +18223,9 @@ return event.junling=='junling5'?1:0;});
 			gzbiluan:'避乱',
 			gzbiluan_info:'锁定技。其他角色计算至你的距离时+X（X为你装备区内的牌数）。',
 			gzrelixia:'礼下',
-			gzrelixia_info:'锁定技。与你势力不同的角色的准备阶段开始时，若你不在其攻击范围内，则其选择一项：①弃置你装备区内的一张牌并失去1点体力。②令你摸一张牌。',
+			gzrelixia_info:'锁定技。与你势力不同的角色的准备阶段，若你不在其攻击范围内，则其选择一项：①弃置你装备区内的一张牌并失去1点体力。②令你摸一张牌。',
 			gzlixia:'礼下',
-			gzlixia_info:'与你势力不同的角色的准备阶段开始时，其可弃置你装备区内的一张牌，然后其选择一项：①弃置两张手牌。②失去1点体力。③令你摸两张牌。',
+			gzlixia_info:'与你势力不同的角色的准备阶段，其可弃置你装备区内的一张牌，然后其选择一项：①弃置两张手牌。②失去1点体力。③令你摸两张牌。',
 			gzrekuangcai:'狂才',
 			gzrekuangcai_info:'锁定技，你于回合内使用牌无距离和次数限制；弃牌阶段开始时，若你本回合内：未使用过牌，则你本局游戏的手牌上限+1；使用过牌但未造成过伤害，则你本局游戏的手牌上限-1。',
 			gzkuangcai:'狂才',
@@ -18022,7 +18264,7 @@ return event.junling=='junling5'?1:0;});
 			gzfengying_info:'限定技，你可以将所有手牌当【挟天子以令诸侯】使用（无视大势力限制），然后所有与你势力相同的角色将手牌补至体力上限。',
 			gz_yujin:'于禁',
 			gzjieyue:'节钺',
-			gzjieyue_info:'准备阶段开始时，你可以将一张手牌交给一名非魏势力角色，然后选择一个“军令”并令其选择一项：执行该军令，然后你摸一张牌；或令你于此回合摸牌阶段额外摸三张牌。',
+			gzjieyue_info:'准备阶段，你可以将一张手牌交给一名非魏势力角色，然后选择一个“军令”并令其选择一项：执行该军令，然后你摸一张牌；或令你于此回合摸牌阶段额外摸三张牌。',
 			gz_wangping:'王平',
 			jianglue:'将略',
 			jianglue_info:'限定技，出牌阶段，你可以选择一个“军令”，然后与你势力相同的其他角色可以执行该军令（未确定势力角色可以在此时明置一张单势力武将牌）。你与所有执行该军令的角色增加1点体力上限，然后回复1点体力，然后你摸X张牌（X为以此法回复了体力的角色数）。',
@@ -18058,7 +18300,7 @@ return event.junling=='junling5'?1:0;});
 			wuziliangjiangdao:'五子良将纛',
 			wuziliangjiangdao_ab:'将纛',
 			wuziliangjiangdao_bg:'纛',
-			wuziliangjiangdao_info:'魏势力角色的准备阶段开始时，其可以弃置一张牌。若如此做，其选择一张暗置的武将牌（若没有，则选择一张暗置），然后获得下列技能中的一项（其他角色已有的技能无法选择）且不能明置选择的武将牌直到你的下个回合开始：〖突袭〗，〖巧变〗，〖骁果〗，〖节钺〗，〖断粮〗。',
+			wuziliangjiangdao_info:'魏势力角色的准备阶段，其可以弃置一张牌。若如此做，其选择一张暗置的武将牌（若没有，则选择一张暗置），然后获得下列技能中的一项（其他角色已有的技能无法选择）且不能明置选择的武将牌直到你的下个回合开始：〖突袭〗，〖巧变〗，〖骁果〗，〖节钺〗，〖断粮〗。',
 			huibian:'挥鞭',
 			huibian_info:'出牌阶段限一次，你可以选择一名魏势力角色和另一名已受伤的魏势力角色。若如此做，你对前者造成1点伤害，然后其摸两张牌，然后后者回复1点体力。',
 			gzzongyu:'总御',
@@ -18121,7 +18363,7 @@ return event.junling=='junling5'?1:0;});
 			"baka_hunshang":"魂殇",
 			"baka_hunshang_info":"副将技，此武将牌减少半个阴阳鱼；准备阶段，若你的体力值不大于1，则你获得〖英姿〗和〖英魂〗直到回合结束。",
 			"baka_yinghun":"英魂",
-			"baka_yinghun_info":"准备阶段开始时，你可令一名其他角色执行一项：摸X张牌，然后弃置一张牌；或摸一张牌，然后弃置X张牌（X为你已损失的体力值）。",
+			"baka_yinghun_info":"准备阶段，你可令一名其他角色执行一项：摸X张牌，然后弃置一张牌；或摸一张牌，然后弃置X张牌（X为你已损失的体力值）。",
 			"baka_yingzi":"英姿",
 			"baka_yingzi_info":"锁定技，摸牌阶段摸，你多摸一张牌；你的手牌上限+X（X为你已损失的体力值）。",
 			gzyiji:"遗计",
@@ -18182,19 +18424,19 @@ return event.junling=='junling5'?1:0;});
 			gzxiongsuan:'凶算',
 			gzxiongsuan_info:'限定技，出牌阶段，你可以弃置一张手牌并选择与你势力相同的一名角色，对其造成1点伤害，然后你摸三张牌。若该角色有已发动的限定技，则你选择其中一个限定技，此回合结束后视为该限定技未发动过。',
 			gzhuashen:'化身',
-			gzhuashen_info:'准备阶段开始时，若你的“化身”不足两张，则你可以观看剩余武将牌堆中的五张牌，然后扣置其中至多两张武将牌在你的武将旁，称为“化身”；若“化身”有两张以上，则你可以用剩余武将牌堆顶的一张牌替换一张“化身”。你可以于相应的时机明置并发动“化身”的一个技能，技能结算完成后将该“化身”放回剩余武将牌堆。你每个时机只能发动一张“化身”的技能，且不能发动带有技能类型的技能（锁定技、限定技等）。',
+			gzhuashen_info:'准备阶段，若你的“化身”不足两张，则你可以观看剩余武将牌堆中的五张牌，然后扣置其中至多两张武将牌在你的武将旁，称为“化身”；若“化身”有两张以上，则你可以用剩余武将牌堆顶的一张牌替换一张“化身”。你可以于相应的时机明置并发动“化身”的一个技能，技能结算完成后将该“化身”放回剩余武将牌堆。你每个时机只能发动一张“化身”的技能，且不能发动带有技能类型的技能（锁定技、限定技等）。',
 			gzxinsheng:'新生',
 			gzxinsheng_info:'当你受到伤害后，你可以从剩余武将牌堆中扣置一张牌加入到“化身”牌中。',
 
 			jubao:'聚宝',
-			jubao_info:'锁定技，你装备区里的宝物牌不能被其他角色获得。结束阶段开始时，若场上或弃牌堆有【定澜夜明珠】，则你摸一张牌，然后获得装备区里有【定澜夜明珠】角色的一张牌。',
+			jubao_info:'锁定技，你装备区里的宝物牌不能被其他角色获得。结束阶段，若场上或弃牌堆有【定澜夜明珠】，则你摸一张牌，然后获得装备区里有【定澜夜明珠】角色的一张牌。',
 			jiahe:'嘉禾',
 			jiahe_info:'君主技，只要此武将牌处于明置状态，你便拥有“缘江烽火图”。',
 			jiahe_put:'烽火',
 			jiahe_put_info:'出牌阶段限一次，你可以将一张装备牌置于“缘江烽火图”上，称之为“烽火”。',
 			jiahe_skill:'缘江烽火图',
 			yuanjiangfenghuotu:'缘江烽火图',
-			yuanjiangfenghuotu_info:'每名吴势力角色的出牌阶段限一次，该角色可以将一张装备牌置于“缘江烽火图”上，称之为“烽火”。<br>根据“烽火”的数量，所有吴势力角色可于其准备阶段开始时选择并获得其中一个技能直到回合结束：一张以上：〖英姿〗；两张以上：〖好施〗；三张以上：〖涉猎〗；四张以上：〖度势〗；五张以上：可额外选择一项。<br>锁定技，当你受到【杀】或锦囊牌造成的伤害后，你将一张“烽火”置入弃牌堆。',
+			yuanjiangfenghuotu_info:'每名吴势力角色的出牌阶段限一次，该角色可以将一张装备牌置于“缘江烽火图”上，称之为“烽火”。<br>根据“烽火”的数量，所有吴势力角色可于其准备阶段选择并获得其中一个技能直到回合结束：一张以上：〖英姿〗；两张以上：〖好施〗；三张以上：〖涉猎〗；四张以上：〖度势〗；五张以上：可额外选择一项。<br>锁定技，当你受到【杀】或锦囊牌造成的伤害后，你将一张“烽火”置入弃牌堆。',
 			yuanjiangfenghuotu_ab:'江图',
 			yuanjiangfenghuotu_bg:'图',
 			wuxin:'悟心',
@@ -18202,7 +18444,7 @@ return event.junling=='junling5'?1:0;});
 			hongfa:'弘法',
 			hongfa_use:'天兵',
 			hongfa_respond:'天兵',
-			hongfa_info:'君主技，锁定技，此武将牌明置时，你获得“黄巾天兵符”；准备阶段开始时，若没有“天兵”，你将牌堆顶的X张牌置于“黄巾天兵符”上，称为“天兵”（X为群势力角色的数量）。',
+			hongfa_info:'君主技，锁定技，此武将牌明置时，你获得“黄巾天兵符”；准备阶段，若没有“天兵”，你将牌堆顶的X张牌置于“黄巾天兵符”上，称为“天兵”（X为群势力角色的数量）。',
 			wendao:'问道',
 			wendao_info:'出牌阶段限一次，你可以弃置一张不为【太平要术】的红色牌，然后获得弃牌堆或场上的一张【太平要术】。',
 			huangjintianbingfu:'黄巾天兵符',
@@ -18243,7 +18485,7 @@ return event.junling=='junling5'?1:0;});
 			gzyongjue:'勇决',
 			gzyongjue_info:'与你势力相同的一名角色于其回合内使用【杀】结算完成后，若此牌是其本回合内使用的第一张牌，则其可以获得此牌对应的所有实体牌。',
 			gzqianxi:'潜袭',
-			gzqianxi_info:'准备阶段开始时，你可以进行判定，然后你选择距离为1的一名角色，直到回合结束，该角色不能使用或打出与结果颜色相同的手牌。',
+			gzqianxi_info:'准备阶段，你可以进行判定，然后你选择距离为1的一名角色，直到回合结束，该角色不能使用或打出与结果颜色相同的手牌。',
 			gzshangyi:'尚义',
 			gzshangyi_info:'出牌阶段限一次，你可以令一名其他角色观看你的手牌。若如此做，你选择一项：1.观看其手牌并可以弃置其中的一张黑色牌；2.观看其所有暗置的武将牌。',
 			niaoxiang:'鸟翔',
@@ -18262,11 +18504,11 @@ return event.junling=='junling5'?1:0;});
 			gzjixi:'急袭',
 			gzjixi_info:'主将技，此武将牌减少半个阴阳鱼。你可以将一张“田”当作【顺手牵羊】使用。',
 			huyuan:'护援',
-			huyuan_info:'结束阶段开始时，你可以将一张装备牌置入一名角色的装备区，然后你可以弃置该角色距离为1的一名角色的一张牌。',
+			huyuan_info:'结束阶段，你可以将一张装备牌置入一名角色的装备区，然后你可以弃置该角色距离为1的一名角色的一张牌。',
 			heyi:'鹤翼',
 			heyi_info:'阵法技。与你处于同一队列的角色视为拥有技能〖飞影〗。',
 			gzhuyuan:'护援',
-			gzhuyuan_info:'结束阶段开始时，你可以选择一项：⒈将一张非装备牌交给一名其他角色。⒉将一张装备牌置入其他角色的装备区内，然后你可以弃置场上的一张牌。',
+			gzhuyuan_info:'结束阶段，你可以选择一项：⒈将一张非装备牌交给一名其他角色。⒉将一张装备牌置入其他角色的装备区内，然后你可以弃置场上的一张牌。',
 			gz_shibing1wei:'魏兵',
 			gz_shibing2wei:'魏兵',
 			gz_shibing1shu:'蜀兵',
@@ -18298,7 +18540,7 @@ return event.junling=='junling5'?1:0;});
 			duoshi:'度势',
 			duoshi_info:'出牌阶段限四次，你可以将一张红色手牌当做【以逸待劳】使用。',
 			gzxiaoguo:'骁果',
-			gzxiaoguo_info:'其他角色的结束阶段开始时，你可以弃置一张基本牌，令该角色选择一项：1.弃置一张装备牌；2.受到你对其造成的1点伤害。',
+			gzxiaoguo_info:'其他角色的结束阶段，你可以弃置一张基本牌，令该角色选择一项：1.弃置一张装备牌；2.受到你对其造成的1点伤害。',
 
 			gzdangxian:'当先',
 			gzdangxian_info:'锁定技。当你首次明置此武将牌时，你获得一枚“先驱”标记。回合开始时，你获得一个额外的出牌阶段。',
@@ -18335,10 +18577,10 @@ return event.junling=='junling5'?1:0;});
 			gzlisi:'离思',
 			gzlisi_info:'一名己方角色死亡后，你可以选择〖诏颂〗中的一个已发动过的选项，令其视为未发动过。',
 			gzcaiyuan:'才媛',
-			gzcaiyuan_info:'锁定技。结束阶段开始时，若你的手牌数大于本回合开始时的手牌数，则你摸两张牌或回复1点体力。',
+			gzcaiyuan_info:'锁定技。结束阶段，若你的手牌数大于本回合开始时的手牌数，则你摸两张牌或回复1点体力。',
 			gzwanyi:'婉嫕',
 			gzwanyi_info:'出牌阶段每项各限一次。你可以将一张带有“合纵”标签的牌当做【联军盛宴】/【火烧连营】/【挟天子以令诸侯】/【戮力同心】使用。',
-			gzwanyi_info_yingbian:'出牌阶段每项各限一次。你可以将一张带有“应变”标签的牌当做【逐近弃远】/【洞烛先机】/【水淹七军】/【出其不意】使用。',
+			gzwanyi_info_guozhan_yingbian:'出牌阶段每项各限一次。你可以将一张带有“应变”标签的牌当做【逐近弃远】/【洞烛先机】/【水淹七军】/【出其不意】使用。',
 			gzmaihuo:'埋祸',
 			gzmaihuo_info:'限定技。当有己方角色成为【杀】的目标时，你可以取消此【杀】的所有目标。然后此【杀】的使用者下回合开始时，其视为对你使用一张【杀】。若此【杀】对你造成伤害，则你防止此伤害，摸两张牌并移除此武将牌（若此武将牌为副将则改为变更副将）。',
 			gzzhenxi:'震袭',
@@ -18394,7 +18636,7 @@ return event.junling=='junling5'?1:0;});
 			gzrebushi:'布施',
 			gzrebushi_info:'①回合结束后，你获得X个“义舍”标记（X为你的体力值）。②其他角色的准备阶段，你可以失去1个“义舍”标记，交给其一张牌并摸两张牌。③准备阶段，你须弃置Y张牌，然后失去所有“义舍”标记（Y为场上存活人数-你的体力值-2）。',
 			gzremidao:'米道',
-			gzremidao_info:'①结束阶段开始时，若你的武将牌上没有“米”，则你可以摸两张牌。若如此做，你将两张牌置于武将牌上，称为“米”。②一名角色的判定牌生效前，你可以打出一张“米”作为新的判定牌，然后你获得原判定牌。',
+			gzremidao_info:'①结束阶段，若你的武将牌上没有“米”，则你可以摸两张牌。若如此做，你将两张牌置于武将牌上，称为“米”。②一名角色的判定牌生效前，你可以打出一张“米”作为新的判定牌，然后你获得原判定牌。',
 			jiahe_reyingzi:'英姿',
 			jiahe_haoshi:'好施',
 			jiahe_shelie:'涉猎',
@@ -18462,7 +18704,7 @@ return event.junling=='junling5'?1:0;});
 			fakepaiyi:'排异',
 			fakepaiyi_info:'出牌阶段限一次，你可以选择一名角色，然后选择一个军令令其选择是否执行。若其执行，则你摸X张牌，然后将一张“权”置入弃牌堆；若其不执行，则你可以对至多X名与其势力相同的角色各造成1点伤害，然后将等量的“权”置入弃牌堆。（X为你武将牌上的“权”数）',
 			fakeshilu:'嗜戮',
-			fakeshilu_info:'①出牌阶段结束时，若你有副将且本阶段未发动过副将武将牌上的非锁定技，则你更换副将并将原副将称为“戮”置于武将牌上。②准备阶段，你弃置X张手牌，然后摸X张牌（X为你武将牌上的“戮”数，少牌全弃，无牌不弃）。',
+			fakeshilu_info:'①出牌阶段结束时，若你有副将且本阶段未发动过副将武将牌上的非锁定技，则你更换副将至你武将牌上的“戮”未包含的势力并将原副将称为“戮”置于武将牌上。②准备阶段，你弃置X张手牌，然后摸X张牌（X为你武将牌上的“戮”数，少牌全弃，无牌不弃）。',
 			fakexiongnve:'凶虐',
 			fakexiongnve_info:'①当你使用【杀】造成伤害时或受到【杀】造成的伤害时，若你武将牌上的“戮”包含伤害来源的势力，则你令此伤害+1。②当你受到不为【杀】造成的伤害时，若你武将牌上的“戮”包含伤害来源的势力，则此伤害-1。',
 			fakehuaiyi:'怀异',
@@ -18488,7 +18730,7 @@ return event.junling=='junling5'?1:0;});
 			fakedujin:'独进',
 			fakedujin_info:'①摸牌阶段，你可以额外摸X张牌（X为你装备区的牌数的一半，向上取整）。②当你首次明置此武将牌时，若你为你们势力第一个明置武将牌的角色，则你获得1个“先驱”标记。',
 			fakezhufu:'注傅',
-			fakezhufu_info:'出牌阶段，你可以弃置一张本阶段未以此法弃置过的花色的牌，然后根据此牌的花色为你使用的下一张牌添加对应的应变效果（无视条件触发）：红桃——助战；方片——富甲；黑桃——残躯；草花——空巢。',
+			fakezhufu_info:'出牌阶段，你可以弃置一张本阶段未以此法弃置过的花色的牌，然后根据此牌的花色为你使用的下一张牌添加对应的应变效果：红桃，助战、目标+1；方片，富甲、不可被响应；黑桃，残躯、摸一张牌；草花，空巢、伤害+1。',
 			fakeguishu:'鬼术',
 			fakeguishu_info:'出牌阶段限一次，你可以将一张黑桃手牌当作【知己知彼】或【远交近攻】使用。若你本局游戏内已经发动过了〖鬼术〗，则你必须选择与上次不同的选项。',
 			fakeyuanyu:'远域',
@@ -18496,7 +18738,7 @@ return event.junling=='junling5'?1:0;});
 			fakemibei:'秘备',
 			fakemibei_info:'①准备阶段，若你的手牌数不为全场最多，则你须选择一名手牌数为全场最多的角色，令其对你发起军令。②当你执行军令后，你将手牌数摸至与发起者相同（至多摸五张）。③当你拒绝执行军令后，你展示一至三张牌，然后你本回合可以将其中一张牌当作另一张基本牌或非延时锦囊牌使用一次。',
 			fakeqizhi:'奇制',
-			fakeqizhi_info:'当你于回合内使用非装备牌A时，你可以弃置不是此牌目标的一名角色的一张牌B，然后其摸一张牌。若A具有应变效果，且A和B的花色相同，则你无视条件触发A的应变效果。',
+			fakeqizhi_info:'当你于回合内声明使用非装备牌A时，你可以弃置不是此牌目标的一名角色的一张牌B，然后其摸一张牌。若A具有应变效果，且A和B的花色相同，则你无视条件触发A的应变效果。',
 			fakejinqu:'进趋',
 			fakejinqu_info:'结束阶段，你可以摸两张牌，然后你将手牌弃置至X张（X为你本回合发动过〖奇制〗的次数）。',
 			fakejuzhan:'拒战',
@@ -18536,7 +18778,7 @@ return event.junling=='junling5'?1:0;});
 			fakeqimei:'齐眉',
 			fakeqimei_info:'准备阶段，你可以选择一名其他角色。若如此做，直到回合结束：当你或其获得牌/失去手牌后，若你与其手牌数相等，则另一名角色回复1点体力；当你或其的体力值变化后，若你与其体力值相等，则另一名角色摸一张牌。',
 			fakebaoqie:'宝箧',
-			fakebaoqie_info:'①当你受到伤害时，若此武将牌未明置过，则你可以明置此武将牌并防止此伤害。②当你首次明置此武将牌时，你可以获得一名角色的宝物牌，然后你可以使用其中的一张牌。',
+			fakebaoqie_info:'①当你受到伤害时，若此武将牌未明置过，则你可以明置此武将牌并防止此伤害。②当你首次明置此武将牌时，你可以获得一名角色装备区里所有的宝物牌，然后你可以使用其中的一张牌。',
 			fakeciwei:'慈威',
 			fakeciwei_info:'其他角色于一回合内使用第偶数张牌时，你可以弃置一张牌并取消此牌的所有目标，然后若此牌为装备牌，你可以获得之且你可以使用之。',
 			fakehuirong:'慧容',
@@ -18557,6 +18799,10 @@ return event.junling=='junling5'?1:0;});
 			fakecaiwang_info:'①你可以助战自己。②每回合每项各限一次，当你响应助战后，若你弃置的牌和被强化的牌：颜色相同，你可以弃置一名其他角色的一张牌；颜色不同，你摸一张牌。',
 			fakenaxiang:'纳降',
 			fakenaxiang_info:'锁定技。①当你对与你势力不同的角色造成伤害后，或受到与你势力不同的角色对你造成的伤害后。你对其发起军令，若其不执行，则你不能对其发动〖纳降①〗直到你的下个回合开始。②你响应助战弃牌无类别限制，且你触发具有应变的卡牌的条件均视为助战。',
+			fakehuyuan:'护援',
+			fakehuyuan_info:'①你的回合内，当一张装备牌进入一名角色的装备区后，你可以弃置与其距离为1以内的另一名角色区域里的一张牌。②结束阶段，你可以将一张装备牌置入一名角色的装备区。',
+			fakekeshou:'恪守',
+			fakekeshou_info:'①当你受到伤害时，你可以弃置两张颜色相同的牌并令此伤害-1。②当你因弃置而一次性失去至少两张牌后，若你的势力已确定且场上没有与你势力相同的其他角色，则你可以进行判定，若结果判定为红色，你摸一张牌。',
 
 			guozhan_default:"国战标准",
 			guozhan_zhen:"君临天下·阵",

node_modules/@types/noname-typings/nonameModules/game/codemirror.d.ts

@@ -1,2 +1,5 @@
-import codemirror from 'codemirror/index';
+export default CodeMirror;
-export = codemirror;
+/**
+ * @type { typeof import('codemirror/index') }
+ */
+declare var CodeMirror: typeof import('codemirror/index');

node_modules/@types/noname-typings/nonameModules/game/jszip.d.ts

@@ -1,2 +0,0 @@
-import * as jszip from 'jszip'
-export = jszip;

node_modules/@types/noname-typings/nonameModules/noname.d.ts

@@ -1,8 +1,8 @@
-export { GNC as gnc } from "./noname/gnc/index.js";
+export { GNC, gnc, setGNC } from './noname/gnc/index.js';
-export { AI as ai } from "./noname/ai/index.js";
+export { AI, ai, setAI } from './noname/ai/index.js';
-export { Game as game } from "./noname/game/index.js";
+export { Game, game, setGame } from './noname/game/index.js';
-export { Get as get } from "./noname/get/index.js";
+export { Get, get, setGet } from './noname/get/index.js';
-export { Library as lib } from "./noname/library/index.js";
+export { Library, lib, setLibrary } from './noname/library/index.js';
-export { status as _status } from "./noname/status/index.js";
+export { status, _status, setStatus } from './noname/status/index.js';
-export { UI as ui } from "./noname/ui/index.js";
+export { UI, ui, setUI } from './noname/ui/index.js';
-export { boot } from "./noname/init/index.js";
+export { boot } from './noname/init/index.js';

node_modules/@types/noname-typings/nonameModules/noname/ai/basic.d.ts

@@ -1,11 +1,11 @@
-export class Basic extends Uninstantable {
+export class Basic {
     /**
      * @param { (
      * 	button: Button,
      * 	buttons?: Button[]
      * ) => number } check
      */
-    static chooseButton(check: (button: Button, buttons?: Button[]) => number): boolean;
+    chooseButton(check: (button: any, buttons?: Button[]) => number): boolean | undefined;
     /**
      * @param { (
      * card?: Card,
@@ -13,13 +13,12 @@ export class Basic extends Uninstantable {
      * ) => number } check
      * @returns { boolean | undefined }
      */
-    static chooseCard(check: (card?: Card, cards?: Card[]) => number): boolean | undefined;
+    chooseCard(check: (card?: any, cards?: Card[]) => number): boolean | undefined;
     /**
      * @param { (
      * target?: Player,
      * targets?: Player[]
      * ) => number } check
      */
-    static chooseTarget(check: (target?: Player, targets?: Player[]) => number): boolean;
+    chooseTarget(check: (target?: any, targets?: Player[]) => number): boolean | undefined;
 }
-import { Uninstantable } from "../util/index.js";

node_modules/@types/noname-typings/nonameModules/noname/ai/index.d.ts

@@ -1,9 +1,8 @@
-export class AI extends Uninstantable {
+export class AI {
-    static basic: typeof Basic;
+    basic: Basic;
-    static get: typeof get;
+    get: import("../get/index.js").Get;
 }
-export const ai: typeof AI;
+export let ai: AI;
+export function setAI(instance?: AI | undefined): void;
 export { Basic };
-import { Uninstantable } from "../util/index.js";
 import { Basic } from './basic.js';
-import { Get as get } from '../get/index.js';

node_modules/@types/noname-typings/nonameModules/noname/game/check.d.ts

@@ -0,0 +1,26 @@
+export class Check {
+    processSelection({ type, items, event, useCache, isSelectable }: {
+        type: any;
+        items: any;
+        event: any;
+        useCache: any;
+        isSelectable: any;
+    }): {
+        ok: boolean;
+        auto: boolean | undefined;
+    };
+    button(event: any, useCache: any): {
+        ok: boolean;
+        auto: boolean | undefined;
+    };
+    card(event: any, useCache: any): {
+        ok: boolean;
+        auto: boolean | undefined;
+    };
+    target(event: any, useCache: any): {
+        ok: boolean;
+        auto: boolean | undefined;
+    };
+    skill(event: any): void;
+    confirm(event: any, confirm: any): void;
+}

node_modules/@types/noname-typings/nonameModules/noname/game/dynamic-style/index.d.ts

@@ -37,7 +37,7 @@ export class DynamicStyle {
      */
     get(name: string): {
         [x: string]: string | number;
-    };
+    } | null;
     /**
      * Callback of `DynamicStyle#find`, getting the rule wanted.
      * `DynamicStyle#find`的回调函数，用于获取符合要求的规则

node_modules/@types/noname-typings/nonameModules/noname/game/promises.d.ts

@@ -1,28 +1,18 @@
-export class GamePromises extends Uninstantable {
+export class GamePromises {
     /**
-     * 模仿h5的prompt，用于显示可提示用户进行输入的对话框
+     * @overload
-     *
+     * @param { string } title
-     * 注: 由于参数列表是随意的，在这里我准备限制一下这个函数的参数顺序
+     * @returns { Promise<string | false> }
-     *
-     * @type {{
-     *  (title: string): Promise<string | false>;
-     *	(title: string, forced: true): Promise<string>;
-     *	(alertOption: 'alert', title: string): Promise<true>;
-     * }}
-     *
-     * @param { string } [title] 设置prompt标题与input内容
-     * @param { boolean } [forced] 为true的话将没有"取消按钮"
-     * @param { string } alertOption 设置prompt是否模拟alert
-     * @example
-     * ```js
-     * // 只设置标题(但是input的初始值就变成了undefined)
-     * game.promises.prompt('###prompt标题').then(value => console.log(value));
-     * // 设置标题和input初始内容
-     * game.promises.prompt('###prompt标题###input初始内容').then(value => console.log(value));
-     * ```
-     * @returns { Promise<string> }
      */
-    static prompt(alertOption: string, title?: string, forced?: boolean): Promise<string>;
+    prompt(title: string): Promise<string | false>;
+    /**
+     * @overload
+     * @param { string } title
+     * @param { boolean } [forced]
+     * @returns { Promise<string> }
+     *
+     */
+    prompt(title: string, forced?: boolean | undefined): Promise<string>;
     /**
      * 模仿h5的alert，用于显示信息的对话框
      *
@@ -33,14 +23,13 @@ export class GamePromises extends Uninstantable {
      * ```
      * @returns { Promise<true> }
      */
-    static alert(title: string): Promise<true>;
+    alert(title: string): Promise<true>;
-    static download(url: any, folder: any, dev: any, onprogress: any): Promise<any>;
+    download(url: any, folder: any, dev: any, onprogress: any): Promise<any>;
-    static readFile(filename: any): Promise<any>;
+    readFile(filename: any): Promise<any>;
-    static readFileAsText(filename: any): Promise<any>;
+    readFileAsText(filename: any): Promise<any>;
-    static writeFile(data: any, path: any, name: any): Promise<any>;
+    writeFile(data: any, path: any, name: any): Promise<any>;
-    static ensureDirectory(list: any, callback: any, file: any): Promise<any>;
+    ensureDirectory(list: any, callback: any, file: any): Promise<any>;
-    static createDir(directory: any): Promise<any>;
+    createDir(directory: any): Promise<any>;
-    static removeFile(filename: any): Promise<void>;
+    removeFile(filename: any): Promise<void>;
-    static removeDir(directory: any): Promise<void>;
+    removeDir(directory: any): Promise<void>;
 }
-import { Uninstantable } from "../util/index.js";

node_modules/@types/noname-typings/nonameModules/noname/get/index.d.ts

@@ -1,5 +1,6 @@
-export class Get extends Uninstantable {
+export class Get {
-    static is: typeof Is;
+    is: Is;
+    promises: Promises;
     /**
      * 获取当前内核版本信息
      *
@@ -9,59 +10,59 @@ export class Get extends Uninstantable {
      *
      * @returns {["firefox" | "chrome" | "safari" | "other", number, number, number]}
      */
-    static coreInfo(): ["firefox" | "chrome" | "safari" | "other", number, number, number];
+    coreInfo(): ["firefox" | "chrome" | "safari" | "other", number, number, number];
     /**
      * 返回 VCard[] 形式的所有牌，用于印卡将遍历
      * @param {Function} filter
      * @returns {string[][]}
      */
-    static inpileVCardList(filter: Function): string[][];
+    inpileVCardList(filter: Function): string[][];
     /**
      * 根据(Player的)座次数n（从1开始）获取对应的“n号位”翻译
      * @param {number | Player} seat
      */
-    static seatTranslation(seat: number | Player): string;
+    seatTranslation(seat: number | Player): string;
     /**
      * @param {number} numberOfPlayers
      * @returns {string[]}
      */
-    static identityList(numberOfPlayers: number): string[];
+    identityList(numberOfPlayers: number): string[];
     /**
      * Generate an object URL from the Base64-encoded octet stream
      *
      * 从Base64编码的八位字节流生成对象URL
      */
-    static objectURL(octetStream: any): any;
+    objectURL(octetStream: any): any;
     /**
      * Get the card name length
      *
      * 获取此牌的字数
      */
-    static cardNameLength(card: any, player: any): number;
+    cardNameLength(card: any, player: any): number;
     /**
      * Get the Yingbian conditions (of the card)
      *
      * 获取（此牌的）应变条件
      */
-    static yingbianConditions(card: any): string[];
+    yingbianConditions(card: any): string[];
-    static complexYingbianConditions(card: any): string[];
+    complexYingbianConditions(card: any): string[];
-    static simpleYingbianConditions(card: any): string[];
+    simpleYingbianConditions(card: any): string[];
     /**
      * Get the Yingbian effects (of the card)
      *
      * 获取（此牌的）应变效果
      */
-    static yingbianEffects(card: any): string[];
+    yingbianEffects(card: any): string[];
     /**
      * Get the default Yingbian effect of the card
      *
      * 获取此牌的默认应变效果
      */
-    static defaultYingbianEffect(card: any): any;
+    defaultYingbianEffect(card: any): any;
     /**
      * 优先度判断
      */
-    static priority(skill: any): any;
+    priority(skill: any): any;
     /**
      * 新装备栏相关
      *
@@ -73,49 +74,49 @@ export class Get extends Uninstantable {
      * @param { false | Player } [player]
      * @returns { string[] }
      */
-    static subtypes(obj: string | Card | VCard | CardBaseUIData, player?: false | Player): string[];
+    subtypes(obj: string | Card | VCard | CardBaseUIData, player?: false | Player): string[];
     /**
      * @returns { string[] }
      */
-    static pinyin(chinese: any, withTone: any): string[];
+    pinyin(chinese: any, withTone: any): string[];
-    static yunmu(str: any): any;
+    yunmu(str: any): any;
     /**
      * 用于将参数转换为字符串，作为缓存的key。
      */
-    static paramToCacheKey(...args: any[]): string;
+    paramToCacheKey(...args: any[]): string;
-    static yunjiao(str: any): string;
+    yunjiao(str: any): string | null;
     /**
      * @param { string } skill
      * @param { Player } player
      * @returns { string[] }
      */
-    static skillCategoriesOf(skill: string, player: Player): string[];
+    skillCategoriesOf(skill: string, player: any): string[];
-    static numOf(obj: any, item: any): any;
+    numOf(obj: any, item: any): any;
-    static connectNickname(): any;
+    connectNickname(): any;
-    static zhinangs(filter: any): any;
+    zhinangs(filter: any): any;
-    static sourceCharacter(str: any): any;
+    sourceCharacter(str: any): any;
-    static isLuckyStar(player: any): boolean;
+    isLuckyStar(player: any): any;
-    static infoHp(hp: any): number;
+    infoHp(hp: any): number;
-    static infoMaxHp(hp: any): number;
+    infoMaxHp(hp: any): number;
-    static infoHujia(hp: any): number;
+    infoHujia(hp: any): number;
-    static bottomCards(num: any, putBack: any): any;
+    bottomCards(num: any, putBack: any): any;
-    static discarded(): any;
+    discarded(): any;
-    static cardOffset(): number;
+    cardOffset(): number;
-    static colorspan(str: any): any;
+    colorspan(str: any): any;
-    static evtprompt(next: any, str: any): void;
+    evtprompt(next: any, str: any): void;
-    static autoViewAs(card: any, cards: any): import("../library/element/vcard.js").VCard;
+    autoViewAs(card: any, cards: any): import("../library/element/vcard.js").VCard;
     /**
      * @deprecated
      */
-    static _autoViewAs(card: any, cards: any): any;
+    _autoViewAs(card: any, cards: any): any;
-    static max(list: any, func: any, type: any): any;
+    max(list: any, func: any, type: any): any;
-    static min(list: any, func: any, type: any): any;
+    min(list: any, func: any, type: any): any;
     /**
      * @overload
      * @param { string } name
      * @returns { Character }
      */
-    static character(name: string): Character;
+    character(name: string): Character;
     /**
      * @template { 0 | 1 | 2 | 3 | 4 } T
      * @overload
@@ -123,24 +124,30 @@ export class Get extends Uninstantable {
      * @param { T } num
      * @returns { Character[T] }
      */
-    static character<T extends 0 | 1 | 2 | 3 | 4>(name: string, num: T): Character[T];
+    character<T extends 0 | 1 | 2 | 3 | 4>(name: string, num: T): Character[T];
-    static characterInitFilter(name: any): string[];
+    characterInitFilter(name: any): string[];
-    static characterIntro(name: any): any;
+    characterIntro(name: any): any;
-    static bordergroup(info: any, raw: any): any;
+    bordergroup(info: any, raw: any): any;
-    static groupnature(group: any, method: any): any;
+    groupnature(group: any, method: any): any;
-    static sgn(num: any): 0 | 1 | -1;
+    sgn(num: any): 0 | 1 | -1;
-    static rand(num: any, num2: any): any;
+    rand(num: any, num2: any): any;
-    static sort(arr: any, method: any, arg: any): any;
+    sort(arr: any, method: any, arg: any): any;
-    static sortSeat(arr: any, target: any): any;
+    sortSeat(arr: any, target: any): any;
-    static zip(callback: any): void;
+    /**
-    static delayx(num: any, max: any): number;
+     * @param { (zip: JSZip) => any } callback
-    static prompt(skill: any, target: any, player: any): string;
+     */
-    static prompt2(skill: any, target: any, player: any, ...args: any[]): any;
+    zip(callback: (zip: JSZip) => any): void;
-    static url(master: any): string;
+    delayx(num: any, max: any): number;
-    static round(num: any, f: any): number;
+    prompt(skill: any, target: any, player: any): string;
-    static playerNumber(): number;
+    prompt2(skill: any, target: any, player: any, ...args: any[]): string;
-    static benchmark(func1: any, func2: any, iteration: any, arg: any): number;
+    url(master: any): string;
-    static stringify(obj: any, level: any): any;
+    round(num: any, f: any): number;
+    playerNumber(): number;
+    benchmark(func1: any, func2: any, iteration: any, arg: any): number | undefined;
+    /**
+     * @param {any} obj
+     */
+    stringify(obj: any, level?: number): any;
     /**
      * 深拷贝函数（虽然只处理了部分情况）
      *
@@ -152,25 +159,25 @@ export class Get extends Uninstantable {
      * @param {WeakMap<object, unknown>} [map] - 拷贝用的临时存储，用于处理循环引用（请勿自行赋值）
      * @returns {T} - 深拷贝后的对象，若传入值不是对象则为传入值
      */
-    static copy<T_1>(obj: T_1, copyKeyDeep?: boolean, map?: WeakMap<object, unknown>): T_1;
+    copy<T_1>(obj: T_1, copyKeyDeep?: boolean | undefined, map?: WeakMap<any, unknown> | undefined): T_1;
-    static inpilefull(type: any): {
+    inpilefull(type: any): {
         name: any;
         suit: any;
         number: any;
         nature: any;
     }[];
-    static inpile(type: any, filter: any): any[];
+    inpile(type: any, filter: any): any[];
-    static inpile2(type: any): any[];
+    inpile2(type: any): any[];
-    static typeCard(type: any, filter: any): string[];
+    typeCard(type: any, filter: any): string[];
-    static libCard(filter: any): string[];
+    libCard(filter: any): string[];
-    static ip(): string;
+    ip(): any;
-    static modetrans(config: any, server: any): string;
+    modetrans(config: any, server: any): string;
-    static charactersOL(func: any): number[];
+    charactersOL(func: any): number[];
-    static trimip(str: any): any;
+    trimip(str: any): any;
-    static mode(): any;
+    mode(): any;
-    static idDialog(id: any): import("../library/element/dialog.js").Dialog;
+    idDialog(id: any): any;
-    static arenaState(): {
+    arenaState(): {
-        number: string;
+        number: string | undefined;
         players: {};
         mode: any;
         dying: any[];
@@ -181,312 +188,313 @@ export class Get extends Uninstantable {
         inpile_nature: any[];
         renku: any[];
     };
-    static skillState(player: any): {
+    skillState(player: any): {
         global: string[];
     };
-    static id(): string;
+    id(): string;
-    static zhu(player: any, skill: any, group: any): any;
+    zhu(player: any, skill: any, group: any): any;
-    static config(item: any, mode: any): any;
+    config(item: any, mode: any): any;
-    static coinCoeff(list: any): number;
+    coinCoeff(list: any): number;
-    static rank(name: any, num: any): number | "x" | "s" | "b" | "c" | "d" | "a" | "ap" | "am" | "bp" | "bm" | "sp";
+    rank(name: any, num: any): number | "x" | "s" | "c" | "d" | "b" | "a" | "ap" | "am" | "bp" | "bm" | "sp";
-    static skillRank(skill: any, type: any, grouped: any): number;
+    skillRank(skill: any, type: any, grouped: any): number;
-    static targetsInfo(targets: any): any[];
+    targetsInfo(targets: any): any[];
-    static infoTargets(infos: any): import("../library/element/player.js").Player[];
+    infoTargets(infos: any): any[];
-    static cardInfo(card: any): any[];
+    cardInfo(card: any): any[];
-    static cardsInfo(cards?: any[]): any[][];
+    cardsInfo(cards?: any[]): any[][];
-    static infoCard(info: any): import("../library/element/card.js").Card;
+    infoCard(info: any): import("../library/element/card.js").Card;
-    static infoCards(infos: any): import("../library/element/card.js").Card[];
+    infoCards(infos: any): import("../library/element/card.js").Card[];
-    static cardInfoOL(card: any): string;
+    cardInfoOL(card: any): string;
-    static infoCardOL(info: any): any;
+    infoCardOL(info: any): any;
-    static cardsInfoOL(cards: any): string[];
+    cardsInfoOL(cards: any): string[];
-    static infoCardsOL(infos: any): any[];
+    infoCardsOL(infos: any): any[];
-    static playerInfoOL(player: any): string;
+    playerInfoOL(player: any): string;
-    static infoPlayerOL(info: any): any;
+    infoPlayerOL(info: any): any;
-    static playersInfoOL(players: any): string[];
+    playersInfoOL(players: any): string[];
-    static infoPlayersOL(infos: any): any[];
+    infoPlayersOL(infos: any): any[];
-    static funcInfoOL(func: any): any;
+    funcInfoOL(func: any): any;
-    static infoFuncOL(info: any): any;
+    infoFuncOL(info: any): any;
-    static eventInfoOL(item: any, level: any, noMore: any): string;
+    eventInfoOL(item: any, level: any, noMore: any): string;
     /**
      * @param {string} item
      */
-    static infoEventOL(item: string): string | import("../library/element/gameEvent.js").GameEvent;
+    infoEventOL(item: string): import("../library/element/gameEvent.js").GameEvent;
-    static stringifiedResult(item: any, level: any, nomore: any): any;
+    stringifiedResult(item: any, level: any, nomore: any): any;
-    static parsedResult(item: any): any;
+    parsedResult(item: any): any;
-    static verticalStr(str: any, sp: any): string;
+    verticalStr(str: any, sp: any): string;
-    static numStr(num: any, method: any): any;
+    numStr(num: any, method: any): any;
-    static rawName(str: any): any;
+    rawName(str: any): any;
     /**
      * 作用修改：只读前缀 不读_ab
      */
-    static rawName2(str: any): any;
+    rawName2(str: any): any;
-    static slimNameHorizontal(str: any): any;
+    slimNameHorizontal(str: any): any;
     /**
      * @param {string} prefix
      * @param {string} name
      * @returns {string}
      */
-    static prefixSpan(prefix: string, name: string): string;
+    prefixSpan(prefix: string, name: string): string;
-    static slimName(str: any): string;
+    slimName(str: any): string;
-    static time(): number;
+    time(): number;
-    static utc(): number;
+    utc(): number;
-    static evtDistance(e1: any, e2: any): number;
+    evtDistance(e1: any, e2: any): number;
-    static xyDistance(from: any, to: any): number;
+    xyDistance(from: any, to: any): number;
     /**
      * @overload
      * @returns { void }
      */
-    static itemtype(): void;
+    itemtype(): void;
     /**
      * @overload
      * @param { string } obj
      * @returns { 'position' | 'natures' | 'nature' }
      */
-    static itemtype(obj: string): 'position' | 'natures' | 'nature';
+    itemtype(obj: string): 'position' | 'natures' | 'nature';
     /**
      * @overload
      * @param { Player[] } obj
      * @returns { 'players' }
      */
-    static itemtype(obj: Player[]): 'players';
+    itemtype(obj: Player[]): 'players';
     /**
      * @overload
      * @param { Card[] } obj
      * @returns { 'cards' }
      */
-    static itemtype(obj: Card[]): 'cards';
+    itemtype(obj: Card[]): 'cards';
     /**
      * @overload
      * @param { [number, number] } obj
      * @returns { 'select' }
      */
-    static itemtype(obj: [number, number]): 'select';
+    itemtype(obj: [number, number]): 'select';
     /**
      * @overload
      * @param { [number, number, number, number] } obj
      * @returns { 'divposition' }
      */
-    static itemtype(obj: [number, number, number, number]): 'divposition';
+    itemtype(obj: [number, number, number, number]): 'divposition';
     /**
      * @overload
      * @param { Button } obj
      * @returns { 'button' }
      */
-    static itemtype(obj: Button): 'button';
+    itemtype(obj: any): 'button';
     /**
      * @overload
      * @param { Card } obj
      * @returns { 'card' }
      */
-    static itemtype(obj: Card): 'card';
+    itemtype(obj: any): 'card';
     /**
      * @overload
      * @param { Player } obj
      * @returns { 'player' }
      */
-    static itemtype(obj: Player): 'player';
+    itemtype(obj: any): 'player';
     /**
      * @overload
      * @param { Dialog } obj
      * @returns { 'dialog' }
      */
-    static itemtype(obj: Dialog): 'dialog';
+    itemtype(obj: any): 'dialog';
     /**
      * @overload
      * @param { GameEvent | GameEventPromise } obj
      * @returns { 'event' }
      */
-    static itemtype(obj: GameEvent | GameEventPromise): 'event';
+    itemtype(obj: GameEvent | GameEventPromise): 'event';
-    static equipNum(card: any): number;
+    equipNum(card: any): number;
-    static objtype(obj: any): "object" | "div" | "array" | "table" | "tr" | "td" | "fragment";
+    objtype(obj: any): "div" | "object" | "array" | "table" | "tr" | "td" | "fragment" | undefined;
-    static type(obj: any, method: any, player: any): any;
+    type(obj: any, method: any, player: any): any;
-    static type2(card: any, player: any): any;
+    type2(card: any, player: any): any;
     /**
      *
      * @param { string | Card | VCard | CardBaseUIData } obj
      * @param { false | Player } [player]
      * @returns { string }
      */
-    static subtype(obj: string | Card | VCard | CardBaseUIData, player?: false | Player): string;
+    subtype(obj: string | Card | VCard | CardBaseUIData, player?: false | Player): string;
-    static equiptype(card: any, player: any): number;
+    equiptype(card: any, player: any): number;
     /**
      *
      * @param { Card | VCard | CardBaseUIData } card
      * @param { false | Player } [player]
      * @returns { string }
      */
-    static name(card: Card | VCard | CardBaseUIData, player?: false | Player): string;
+    name(card: Card | VCard | CardBaseUIData, player?: false | Player): string;
     /**
      * @param {Card | VCard | Card[] | VCard[]} card
      * @param {false | Player} [player]
      * @returns {string}
      */
-    static suit(card: Card | VCard | Card[] | VCard[], player?: false | Player): string;
+    suit(card: Card | VCard | Card[] | VCard[], player?: false | Player): string;
     /**
      * @param {Card | VCard | Card[] | VCard[]} card
      * @param {false | Player} [player]
      * @returns {string}
      */
-    static color(card: Card | VCard | Card[] | VCard[], player?: false | Player): string;
+    color(card: Card | VCard | Card[] | VCard[], player?: false | Player): string;
     /**
      * @param {Card | VCard} card
      * @param {false | Player} [player]
      * @returns {number}
      */
-    static number(card: Card | VCard, player?: false | Player): number;
+    number(card: Card | VCard, player?: false | Player): number;
     /**
      * 返回一张杀的属性。如有多种属性则用`lib.natureSeparator`分割开来。例：火雷【杀】的返回值为`fire|thunder`
      * @param {string | string[] | Card | VCard} card
      * @param {false | Player} [player]
      * @returns {string}
      */
-    static nature(card: string | string[] | Card | VCard, player?: false | Player): string;
+    nature(card: string | string[] | Card | VCard, player?: false | Player): string;
     /**
      * 返回包含所有属性的数组
      * @param {string[] | string} card
      * @param {false | Player} [player]
      * @returns {string[]}
      */
-    static natureList(card: string[] | string, player?: false | Player): string[];
+    natureList(card: string[] | string, player?: false | Player): string[];
-    static cards(num: any, putBack: any): any;
+    cards(num: any, putBack: any): any;
-    static judge(card: any): any;
+    judge(card: any): any;
-    static judge2(card: any): any;
+    judge2(card: any): any;
-    static distance(from: any, to: any, method: any): number;
+    distance(from: any, to: any, method: any): number;
     /**
      * @overload
      * @param { string } item
      * @returns { Skill }
      */
-    static info(item: string): Skill;
+    info(item: string): Skill;
     /**
      * @overload
      * @param { Card | VCard | CardBaseUIData } item
      * @param { Player | false } [player]
      * @returns { any }
      */
-    static info(item: Card | VCard | CardBaseUIData, player?: Player | false): any;
+    info(item: Card | VCard | CardBaseUIData, player?: Player | false): any;
     /**
      * @param { number | Select | (()=>Select) } [select]
      * @returns { Select }
      */
-    static select(select?: number | Select | (() => Select)): Select;
+    select(select?: number | Select | (() => Select) | undefined): Select;
-    static card(original: any): any;
+    card(original: any): any;
     /**
      * @overload
      * @returns {GameEvent}
      */
-    static event(): GameEvent;
+    event(): any;
     /**
      * @template { keyof GameEvent } T
      * @overload
      * @param {T} key
      * @returns {GameEvent[T]}
      */
-    static event<T_2 extends keyof import("../library/element/gameEvent.js").GameEvent>(key: T_2): import("../library/element/gameEvent.js").GameEvent[T_2];
+    event<T_2 extends string | number | symbol>(key: T_2): any;
-    static player(): import("../library/element/player.js").Player;
+    player(): any;
-    static players(sort: any, dead: any, out: any): import("../library/element/player.js").Player[];
+    players(sort: any, dead: any, out: any): any[];
-    static position(card: any, ordering: any): number | "x" | "s" | "e" | "j" | "h" | "c" | "d" | "o";
+    position(card: any, ordering: any): number | "e" | "j" | "x" | "s" | "h" | "c" | "d" | "o" | null | undefined;
-    static skillTranslation(str: any, player: any): string;
+    skillTranslation(str: any, player: any): string;
-    static skillInfoTranslation(name: any, player: any): any;
+    skillInfoTranslation(name: any, player: any): any;
     /**
      * @returns {string}
      */
-    static translation(str: any, arg: any): string;
+    translation(str: any, arg: any): string;
-    static menuZoom(): any;
+    menuZoom(): any;
-    static strNumber(num: any): any;
+    strNumber(num: any): any;
-    static cnNumber(num: any, ordinal: any): any;
+    cnNumber(num: any, ordinal: any): any;
     /**
      * 遍历子元素
      * @param {HTMLElement} node
      * @returns {Iterable<HTMLElement>} 迭代器
      */
-    static iterableChildNodes(node: HTMLElement, ...args: any[]): Iterable<HTMLElement>;
+    iterableChildNodes(node: HTMLElement, ...args: any[]): Iterable<HTMLElement>;
     /**
      * @param {((a: Button, b: Button) => number)} [sort] 排序函数
      * @returns { Button[] }
      */
-    static selectableButtons(sort?: (a: Button, b: Button) => number): Button[];
+    selectableButtons(sort?: ((a: any, b: any) => number) | undefined): Button[];
     /**
      * @param {((a: Card, b: Card) => number)} [sort] 排序函数
      * @returns { Card[] }
      */
-    static selectableCards(sort?: (a: Card, b: Card) => number): Card[];
+    selectableCards(sort?: ((a: any, b: any) => number) | undefined): Card[];
     /**
      * @returns { string[] } 技能名数组
      */
-    static skills(): string[];
+    skills(): string[];
-    static gainableSkills(func: any, player: any): any[];
+    gainableSkills(func: any, player: any): any[];
-    static gainableSkillsName(name: any, func: any): any[];
+    gainableSkillsName(name: any, func: any): any[];
-    static gainableCharacters(func: any): string[];
+    gainableCharacters(func: any): string[];
     /**
      * @param {((a: Player, b: Player) => number)} [sort] 排序函数
      * @returns { Player[] }
      */
-    static selectableTargets(sort?: (a: Player, b: Player) => number): Player[];
+    selectableTargets(sort?: ((a: any, b: any) => number) | undefined): Player[];
-    static filter(filter: any, i: any): any;
+    filter(filter: any, i: any): any;
-    static cardCount(card: any, player: any): any;
+    cardCount(card: any, player: any): any;
-    static skillCount(skill: any, player: any): any;
+    skillCount(skill: any, player: any): any;
-    static owner(card: any, method: any): import("../library/element/player.js").Player;
+    owner(card: any, method: any): any;
-    static noSelected(): boolean;
+    noSelected(): boolean;
-    static population(identity: any): number;
+    population(identity: any): number;
-    static totalPopulation(identity: any): number;
+    totalPopulation(identity: any): number;
     /**
      * @param { Card | VCard } item
      */
-    static cardtag(item: Card | VCard, tag: any): any;
+    cardtag(item: Card | VCard, tag: any): any;
-    static tag(item: any, tag: any, item2: any, bool: any): any;
+    tag(item: any, tag: any, item2: any, bool: any): any;
-    static sortCard(sort: any): (card: any) => any;
+    sortCard(sort: any): ((card: any) => any) | undefined;
-    static difficulty(): 2 | 1 | 3;
+    difficulty(): 2 | 1 | 3;
-    static cardPile(name: any, create: any): any;
+    cardPile(name: any, create: any): any;
-    static cardPile2(name: any): any;
+    cardPile2(name: any): any;
-    static discardPile(name: any): any;
+    discardPile(name: any): any;
-    static aiStrategy(): 2 | 1 | 3 | 4 | 5 | 6;
+    aiStrategy(): 2 | 1 | 3 | 4 | 5 | 6;
-    static skillintro(name: any, learn: any, learn2: any): string;
+    skillintro(name: any, learn: any, learn2: any): string;
-    static intro(name: any): string;
+    intro(name: any): string;
-    static storageintro(type: any, content: any, player: any, dialog: any, skill: any): any;
+    storageintro(type: any, content: any, player: any, dialog: any, skill: any): any;
-    static nodeintro(node: any, simple: any, evt: any): import("../library/element/dialog.js").Dialog;
+    nodeintro(node: any, simple: any, evt: any): import("../library/element/dialog.js").Dialog | undefined;
-    static linkintro(dialog: any, content: any, player: any): void;
+    linkintro(dialog: any, content: any, player: any): void;
-    static groups(): string[];
+    groups(): string[];
-    static types(): any[];
+    types(): any[];
-    static links(buttons: any): any[];
+    links(buttons: any): any[];
-    static threaten(target: any, player: any, hp: any): number;
+    threaten(target: any, player: any, hp: any): number;
-    static condition(player: any): any;
+    condition(player: any): any;
-    static attitude(from: any, to: any, ...args: any[]): any;
+    attitude(from: any, to: any, ...args: any[]): any;
-    static sgnAttitude(...args: any[]): 0 | 1 | -1;
+    sgnAttitude(...args: any[]): 0 | 1 | -1;
-    static useful_raw(card: any, player: any): any;
+    useful_raw(card: any, player: any): any;
-    static useful(card: any, player: any): any;
+    useful(card: any, player: any): any;
-    static unuseful(card: any): number;
+    unuseful(card: any): number;
-    static unuseful2(card: any): number;
+    unuseful2(card: any): number;
-    static unuseful3(card: any): number;
+    unuseful3(card: any): number;
-    static value(card: any, player: any, method: any): any;
+    value(card: any, player: any, method: any): any;
-    static equipResult(player: any, target: any, name: any): number;
+    equipResult(player: any, target: any, name: any): number;
-    static equipValue(card: any, player: any): number;
+    equipValue(card: any, player: any): any;
-    static equipValueNumber(card: any): number;
+    equipValueNumber(card: any): any;
-    static disvalue(card: any, player: any): number;
+    disvalue(card: any, player: any): number;
-    static disvalue2(card: any, player: any): number;
+    disvalue2(card: any, player: any): number;
-    static skillthreaten(skill: any, player: any, target: any): number | void;
+    skillthreaten(skill: any, player: any, target: any): number | void;
-    static cacheOrder(item: any): number;
+    cacheOrder(item: any): number;
     /**
      * @returns { number }
      */
-    static order(item: any, player?: import("../library/element/player.js").Player): number;
+    order(item: any, player?: any): number;
-    static result(item: any, skill: any): any;
+    result(item: any, skill: any): any;
-    static cacheEffectUse(target: any, card: any, player: any, player2: any, isLink: any): number;
+    cacheEffectUse(target: any, card: any, player: any, player2: any, isLink: any): number;
-    static effect_use(target: any, card: any, player: any, player2: any, isLink: any): number;
+    effect_use(target: any, card: any, player: any, player2: any, isLink: any): number;
-    static cacheEffect(target: any, card: any, player: any, player2: any, isLink: any): number;
+    cacheEffect(target: any, card: any, player: any, player2: any, isLink: any): number;
-    static effect(target: any, card: any, player: any, player2: any, isLink: any): number;
+    effect(target: any, card: any, player: any, player2: any, isLink: any): number;
-    static damageEffect(target: any, player: any, viewer: any, nature: any): any;
+    damageEffect(target: any, player: any, viewer: any, nature: any): any;
     /**
      *
      * @param {any} source 如果参数是function，执行此函数并返回结果，传参为此方法剩余的参数。如果参数不是function，直接返回结果。
      * @returns 返回的结果
      */
-    static dynamicVariable(source: any, ...args: any[]): any;
+    dynamicVariable(source: any, ...args: any[]): any;
-    static recoverEffect(target: any, player: any, viewer: any): number;
+    recoverEffect(target: any, player: any, viewer: any): number;
-    static buttonValue(button: any): number;
+    buttonValue(button: any): number;
-    static attitude2(to: any): any;
+    attitude2(to: any): any;
 }
-export const get: typeof Get;
+export let get: Get;
-export { Is };
+export function setGet(instance?: Get | undefined): void;
-import { Uninstantable } from "../util/index.js";
 import { Is } from "./is.js";
+import { Promises } from "./promises.js";
+export { Is, Promises };

node_modules/@types/noname-typings/nonameModules/noname/get/is.d.ts

@@ -1,89 +1,89 @@
-export class Is extends Uninstantable {
+export class Is {
     /**
      * 判断是否为进攻坐骑
      * @param { Card | VCard } card
      * @param { false | Player } [player]
      * @returns { boolean }
      */
-    static attackingMount(card: Card | VCard, player?: false | Player): boolean;
+    attackingMount(card: Card | VCard, player?: false | Player): boolean;
     /**
      * 判断是否为防御坐骑
      * @param { Card | VCard } card
      * @param { false | Player } [player]
      * @returns { boolean }
      */
-    static defendingMount(card: Card | VCard, player?: false | Player): boolean;
+    defendingMount(card: Card | VCard, player?: false | Player): boolean;
     /**
      * 判断坐骑栏是否被合并
      * @returns { boolean }
      */
-    static mountCombined(): boolean;
+    mountCombined(): boolean;
     /**
      * 判断传入的参数的属性是否相同（参数可以为卡牌、卡牌信息、属性等）
      * @param {...} infos 要判断的属性列表
      * @param {boolean} every 是否判断每一个传入的属性是否完全相同而不是存在部分相同
      */
-    static sameNature(...args: any[]): boolean;
+    sameNature(...args: any[]): boolean;
     /**
      * 判断传入的参数的属性是否不同（参数可以为卡牌、卡牌信息、属性等）
      * @param ...infos 要判断的属性列表
      * @param every {boolean} 是否判断每一个传入的属性是否完全不同而不是存在部分不同
      */
-    static differentNature(...args: any[]): boolean;
+    differentNature(...args: any[]): boolean;
     /**
      * 判断一张牌是否为明置手牌
      * @param { Card } card
      */
-    static shownCard(card: Card): boolean;
+    shownCard(card: any): boolean;
     /**
      * 是否是虚拟牌
      * @param { Card | VCard } card
      */
-    static virtualCard(card: Card | VCard): boolean;
+    virtualCard(card: Card | VCard): boolean;
     /**
      * 是否是转化牌
      * @param { Card | VCard } card
      */
-    static convertedCard(card: Card | VCard): boolean;
+    convertedCard(card: Card | VCard): boolean;
     /**
      * 是否是实体牌
      * @param { Card | VCard } card
      */
-    static ordinaryCard(card: Card | VCard): boolean;
+    ordinaryCard(card: Card | VCard): any;
     /**
      * 押韵判断
      * @param { string } str1
      * @param { string } str2
      */
-    static yayun(str1: string, str2: string): boolean;
+    yayun(str1: string, str2: string): boolean;
     /**
      * @param { string } skill 技能id
      * @param { Player } player 玩家
      * @returns
      */
-    static blocked(skill: string, player: Player): boolean;
+    blocked(skill: string, player: any): boolean;
     /**
      * 是否是双势力武将
      * @param { string } name
      * @param { string[] } array
      * @returns { boolean | string[] }
      */
-    static double(name: string, array: string[]): boolean | string[];
+    double(name: string, array: string[]): boolean | string[];
     /**
      * Check if the card has a Yingbian condition
      *
      * 检测此牌是否具有应变条件
      * @param { Card | VCard } card
      */
-    static yingbianConditional(card: Card | VCard): boolean;
+    yingbianConditional(card: Card | VCard): boolean;
     /**
      * @param { Card | VCard } card
      */
-    static complexlyYingbianConditional(card: Card | VCard): boolean;
+    complexlyYingbianConditional(card: Card | VCard): boolean;
     /**
      * @param { Card | VCard } card
      */
-    static simplyYingbianConditional(card: Card | VCard): boolean;
+    simplyYingbianConditional(card: Card | VCard): boolean;
     /**
      * Check if the card has a Yingbian effect
      *
@@ -91,104 +91,103 @@ export class Is extends Uninstantable {
      *
      * @param { Card | VCard } card
      */
-    static yingbianEffective(card: Card | VCard): boolean;
+    yingbianEffective(card: Card | VCard): boolean;
     /**
      * @param { Card | VCard } card
      */
-    static yingbian(card: Card | VCard): boolean;
+    yingbian(card: Card | VCard): boolean;
     /**
      * @param { string } [substring]
      */
-    static emoji(substring?: string): boolean;
+    emoji(substring?: string | undefined): boolean;
     /**
      * @param { string } str
      */
-    static banWords(str: string): boolean;
+    banWords(str: string): boolean;
     /**
      * @param { GameEventPromise } event
      */
-    static converted(event: GameEventPromise): boolean;
+    converted(event: any): boolean;
-    static safari(): boolean;
+    safari(): boolean;
     /**
      * @param { (Card | VCard)[]} cards
      */
-    static freePosition(cards: (Card | VCard)[]): boolean;
+    freePosition(cards: (Card | VCard)[]): boolean;
     /**
      * @param { string } name
      * @param { boolean } item
      */
-    static nomenu(name: string, item: boolean): boolean;
+    nomenu(name: string, item: boolean): boolean;
-    static altered(skillName: any): boolean;
+    altered(skillName: any): boolean;
     /**
      * @param { any } obj
      * @returns { boolean }
      */
-    static node(obj: any): boolean;
+    node(obj: any): boolean;
     /**
      * @param { any } obj
      */
-    static div(obj: any): boolean;
+    div(obj: any): boolean;
     /**
      * @param { any } obj
      */
-    static map(obj: any): boolean;
+    map(obj: any): boolean;
     /**
      * @param { any } obj
      */
-    static set(obj: any): boolean;
+    set(obj: any): boolean;
     /**
      * @param { any } obj
      */
-    static object(obj: any): boolean;
+    object(obj: any): boolean;
     /**
      * @overload
      * @param { Function } func
      * @returns { false }
      */
-    static singleSelect(func: Function): false;
+    singleSelect(func: Function): false;
     /**
      * @overload
      * @param { number | [number, number] } func
      * @returns { boolean }
      */
-    static singleSelect(func: number | [number, number]): boolean;
+    singleSelect(func: number | [number, number]): boolean;
     /**
      * @param { string | Player } name
      */
-    static jun(name: string | Player): boolean;
+    jun(name: string | Player): boolean;
-    static versus(): boolean;
+    versus(): boolean;
-    static changban(): boolean;
+    changban(): boolean;
-    static single(): boolean;
+    single(): boolean;
     /**
      * @param { Player } [player]
      */
-    static mobileMe(player?: Player): boolean;
+    mobileMe(player?: any): any;
-    static newLayout(): boolean;
+    newLayout(): boolean;
-    static phoneLayout(): boolean;
+    phoneLayout(): boolean;
-    static singleHandcard(): any;
+    singleHandcard(): any;
     /**
      * @param { Player } player
      */
-    static linked2(player: Player): boolean;
+    linked2(player: any): boolean;
     /**
      * @param { {} } obj
      */
-    static empty(obj: {}): boolean;
+    empty(obj: {}): boolean;
     /**
      * @param { string } str
      */
-    static pos(str: string): boolean;
+    pos(str: string): boolean;
     /**
      * @param { string } skill
      * @param { Player } player
      * @returns
      */
-    static locked(skill: string, player: Player): any;
+    locked(skill: string, player: any): any;
     /**
      * @param { string } skill
      * @param { Player } player
      * @returns
      */
-    static zhuanhuanji(skill: string, player: Player): boolean;
+    zhuanhuanji(skill: string, player: any): boolean;
 }
-import { Uninstantable } from "../util/index.js";

node_modules/@types/noname-typings/nonameModules/noname/get/promises.d.ts

@@ -0,0 +1,6 @@
+export class Promises {
+    /**
+     * @returns { Promise<JSZip> }
+     */
+    zip(): Promise<JSZip>;
+}

node_modules/@types/noname-typings/nonameModules/noname/gnc/index.d.ts

@@ -1,12 +1,12 @@
-export class GNC extends Uninstantable {
+export class GNC {
     /**
      * @param {GeneratorFunction} fn
      * @returns
      */
-    static of(fn: GeneratorFunction): (...args: any[]) => Promise<Generator<unknown, any, unknown>>;
+    of(fn: GeneratorFunction): (...args: any[]) => Promise<Generator<unknown, any, unknown>>;
-    static is: typeof Is;
+    is: Is;
 }
-export const gnc: typeof GNC;
+export let gnc: GNC;
-import { Uninstantable } from "../util/index.js";
+export function setGNC(instance?: GNC | undefined): void;
 import { GeneratorFunction } from "../util/index.js";
 import { Is } from "./is.js";

node_modules/@types/noname-typings/nonameModules/noname/gnc/is.d.ts

@@ -1,18 +1,17 @@
-export class Is extends Uninstantable {
+export class Is {
     /**
      * @param {*} item
      * @returns {boolean}
      */
-    static coroutine(item: any): boolean;
+    coroutine(item: any): boolean;
     /**
      * @param {*} item
      * @returns {boolean}
      */
-    static generatorFunc(item: any): boolean;
+    generatorFunc(item: any): boolean;
     /**
      * @param {*} item
      * @returns {boolean}
      */
-    static generator(item: any): boolean;
+    generator(item: any): boolean;
 }
-import { Uninstantable } from "../util/index.js";

node_modules/@types/noname-typings/nonameModules/noname/init/index.d.ts

@@ -1,4 +1,4 @@
-export function canUseHttpProtocol(): boolean;
+export function canUseHttpProtocol(): any;
 /**
  * 传递升级完成的信息
  * @returns { string | void } 返回一个网址

node_modules/@types/noname-typings/nonameModules/noname/library/announce/index.d.ts

@@ -1,30 +1,32 @@
-import { NonameAnnounceType } from "./interface.d.ts"
+/**
-
+ * @template T
-export interface IAnnounceSubscriber {
+ * @typedef {import("./index").AnnounceSubscriberType<T>} AnnounceSubscriberType
-	subscribe(name: string): void;
+ */
-	unsubscribe(name: string): void;
+/**
-
+ * @typedef {import("./index").IAnnounceSubscriber} IAnnounceSubscriber
-	get isEmpty(): boolean
+ */
-}
+/**
-
+ *
-export type AnnounceSubscriberType<T> = new (
+ */
-	content: (value: T, name: string) => void,
-	target: EventTarget
-) => IAnnounceSubscriber;
-
 export class Announce {
-	constructor(eventTarget: EventTarget, records: WeakMap<((arg0: any) => void), IAnnounceSubscriber>, SubscriberType: AnnounceSubscriberType<any> = AnnounceSubscriber)
+    /**
-
+     *
+     * @param {EventTarget} eventTarget
+     * @param {WeakMap<function(any): void, IAnnounceSubscriber>} records
+     * @param {AnnounceSubscriberType<any>} [SubscriberType]
+     */
+    constructor(eventTarget: EventTarget, records: WeakMap<(arg0: any) => void, IAnnounceSubscriber>, SubscriberType?: AnnounceSubscriberType<any> | undefined);
     /**
      * 推送任意数据给所有监听了指定事件的订阅者，并返回给定的数据
      *
      * 若不存在订阅指定事件的订阅者，则推送的数据将无意义
      *
-	 * @param name - 要推送事件的名称
+     * @template T
-	 * @param values - 要推送的数据
+     * @param {string} name - 要推送事件的名称
+     * @param {T} values - 要推送的数据
+     * @returns {T}
      */
-	publish<Type extends NonameAnnounceType, Name extends keyof Type>(name: Name, values: Parameters<Type[Name]>[0]): Parameters<Type[Name]>[0]
+    publish<T>(name: string, values: T): T;
-
     /**
      * 订阅给定名字的事件，并返回给定的函数
      *
@@ -32,22 +34,45 @@ export class Announce {
      *
      * 给定的函数将被存储至当前实例中，用于取消订阅时获取
      *
-	 * @param name - 要订阅事件的名称
+     * @template T
-	 * @param method - 事件触发时执行的函数
+     * @param {string} name - 要订阅事件的名称
+     * @param {(values: T) => void} method - 事件触发时执行的函数
+     * @returns {(values: T) => void}
      */
-	subscribe<Type extends NonameAnnounceType, Name extends keyof Type>(name: Name, method: Type[Name]): Type[Name]
+    subscribe<T_1>(name: string, method: (values: T_1) => void): (values: T_1) => void;
-
     /**
      * 取消指定事件某一个函数的订阅，并返回该函数
      *
      * 给定的函数将不再于事件触发时执行，其余同事件需触发的函数不受限制
      *
-	 * @param name - 要取消订阅事件的名称
+     * @template T
-	 * @param method - 订阅指定事件的函数
+     * @param {string} name - 要取消订阅事件的名称
+     * @param {(values: T) => void} method - 订阅指定事件的函数
+     * @returns {(values: T) => void}
      */
-	unsubscribe<Type extends NonameAnnounceType, Name extends keyof Type>(name: Name, method: Type[Name]): Type[Name]
+    unsubscribe<T_2>(name: string, method: (values: T_2) => void): (values: T_2) => void;
+    #private;
 }
-
+/**
-export class AnnounceSubscriber<T> implements IAnnounceSubscriber {
+ * @template T
-	constructor(content: (value: T, name: string) => void, target: EventTarget)
+ */
+export class AnnounceSubscriber<T> {
+    /**
+     *
+     * @param {function(T, string): void} content
+     * @param {EventTarget} target
+     */
+    constructor(content: (arg0: T, arg1: string) => void, target: EventTarget);
+    get isEmpty(): boolean;
+    /**
+     * @param {string} name
+     */
+    subscribe(name: string): void;
+    /**
+     * @param {string} name
+     */
+    unsubscribe(name: string): void;
+    #private;
 }
+export type AnnounceSubscriberType<T> = import("./index").AnnounceSubscriberType<T>;
+export type IAnnounceSubscriber = import("./index").IAnnounceSubscriber;

node_modules/@types/noname-typings/nonameModules/noname/library/announce/interface.d.ts

@@ -1,54 +0,0 @@
-
-export interface NonameAnnounceType {
-    // Apperaence 外观区域
-    // 用于关于无名杀外观方面的通知
-
-    // Apperaence.Theme 无名杀主题区域
-    /**
-     * 主题正在被切换时通知
-     * 
-     * @param values - 主题名称
-     */
-    "Noname.Apperaence.Theme.onChanging": AnnounceFunction<string>
-
-    /**
-     * 主题被切换时通知
-     * 
-     * @param values - 主题名称
-     */
-    "Noname.Apperaence.Theme.onChanged": AnnounceFunction<string>
-
-    /**
-     * 主题被切换时，已经显示完毕后通知
-     * 
-     * @param values - 主题名称
-     */
-    "Noname.Apperaence.Theme.onChangeFinished": AnnounceFunction<string>
-
-    // Game 游戏区域
-    // 包含游戏对局下的通知
-
-    // Game.Event 事件区域
-    /**
-     * 当游戏对局开始时进行通知
-     * 
-     * @param values - 空对象
-     */
-    "Noname.Game.Event.GameStart": AnnounceFunction<{}>
-
-
-    // Init 初始化区域
-    // 用于关于初始化方面的通知
-
-    // Init.Extension 扩展初始化区域
-    /**
-     * 当扩展初始化完成时通知
-     * 
-     * @param values - 扩展名称
-     */
-    "Noname.Init.Extension.onLoad": AnnounceFunction<string>
-
-
-}
-
-export type AnnounceFunction<T> = (values: T) => void

node_modules/@types/noname-typings/nonameModules/noname/library/cache/cacheContext.d.ts

@@ -33,14 +33,14 @@ export class CacheContext {
      * @param {Array<string>} methods
      * @returns
      */
-    static inject(source: any, methods: Array<string>): any;
+    static inject(source: any, methods: Array<string>): null | undefined;
     static _getCacheValueFromObject(storage: any, key: any, params: any, source: any, func: any): any;
     static _ensureMember(obj: any, key: any): any;
     static _wrapParametersToCacheKey(params: any): string;
     static _wrapParameterToCacheKey(param: any): any;
-    lib: typeof Library;
+    lib: import("../index.js").Library;
-    game: typeof Game;
+    game: import("../../game/index.js").Game;
-    get: typeof Get;
+    get: import("../../get/index.js").Get;
     sourceMap: Map<any, any>;
     storageMap: Map<any, any>;
     /**
@@ -59,6 +59,3 @@ export class CacheContext {
      */
     _createCacheProxy<T>(delegateObject: T): T;
 }
-import { Library } from "../index.js";
-import { Game } from "../../game/index.js";
-import { Get } from "../../get/index.js";

node_modules/@types/noname-typings/nonameModules/noname/library/channel/index.d.ts

@@ -9,7 +9,7 @@ export class Channel<T> {
     /**
      * @type {PromiseResolve<T> | [T, PromiseResolve<void>] | null}
      */
-    _buffer: ((value?: T | PromiseLike<T>) => void) | [T, (value?: void | PromiseLike<void>) => void];
+    _buffer: ((value?: T | PromiseLike<T> | undefined) => void) | [T, (value?: void | PromiseLike<void> | undefined) => void] | null;
     /**
      * 向该频道发送消息，在消息未被接受前将等待
      *

node_modules/@types/noname-typings/nonameModules/noname/library/element/button.d.ts

@@ -6,8 +6,12 @@ export class Button extends HTMLDivElement {
      * @param {true} [noClick]
      * @param { Button } [button]
      */
-    constructor(item: {}, type: "character" | "tdnodes" | "blank" | "card" | "vcard" | "characterx" | "player" | ((item: {}, type: Function, position?: HTMLDivElement | DocumentFragment, noClick?: true, button?: Button) => Button), position?: HTMLDivElement | DocumentFragment, noClick?: true, button?: Button);
+    constructor(item: {}, type: "character" | "tdnodes" | "blank" | "card" | "vcard" | "characterx" | "player" | ((item: {}, type: Function, position?: HTMLDivElement | DocumentFragment, noClick?: true, button?: Button) => Button), position?: HTMLDivElement | DocumentFragment | undefined, noClick?: true | undefined, button?: Button | undefined);
+    /**
+     * @type { string | undefined }
+     */
+    buttonid: string | undefined;
     exclude(): void;
     get updateTransform(): (bool: any, delay: any) => void;
 }
-import { UI as ui } from '../../ui/index.js';
+import { ui } from '../../ui/index.js';

node_modules/@types/noname-typings/nonameModules/noname/library/element/card.d.ts

@@ -2,12 +2,12 @@ export class Card extends HTMLDivElement {
     /**
      * @param {HTMLDivElement|DocumentFragment} [position]
      */
-    constructor(position?: HTMLDivElement | DocumentFragment);
+    constructor(position?: HTMLDivElement | DocumentFragment | undefined);
     /**
      * @param {'noclick'} [info]
      * @param {true} [noclick]
      */
-    build(info?: 'noclick', noclick?: true): this;
+    build(info?: "noclick" | undefined, noclick?: true | undefined): this;
     buildEventListener(info: any): void;
     buildProperty(): void;
     /**
@@ -38,8 +38,8 @@ export class Card extends HTMLDivElement {
     willBeDestroyed(targetPosition: any, player: any, event: any): any;
     hasNature(nature: any, player: any): boolean;
     addNature(nature: any): string;
-    nature: string;
+    nature: string | undefined;
-    removeNature(nature: any): string;
+    removeNature(nature: any): string | undefined;
     addGaintag(gaintag: any): void;
     removeGaintag(tag: any): void;
     hasGaintag(tag: any): boolean;
@@ -57,10 +57,10 @@ export class Card extends HTMLDivElement {
         name: string;
         nature: string;
     }): this;
-    suit: string;
+    suit: string | undefined;
-    number: number;
+    number: number | undefined;
     destroyed: any;
-    cardid: string;
+    cardid: string | undefined;
     /**
      * @param {[string, number, string, string]} card
     */
@@ -68,17 +68,17 @@ export class Card extends HTMLDivElement {
     updateTransform(bool: any, delay: any): void;
     aiexclude(): void;
     addKnower(player: any): void;
-    _knowers: any[];
+    _knowers: any[] | undefined;
     removeKnower(player: any): void;
     clearKnowers(): void;
     isKnownBy(player: any): boolean;
     getSource(name: any): any;
     moveDelete(player: any): void;
-    fixed: boolean;
+    fixed: boolean | undefined;
     _onEndMoveDelete: any;
     moveTo(player: any): this;
     copy(...args: any[]): Card;
-    clone: Card;
+    clone: Card | undefined;
     uncheck(skill: any): void;
     recheck(skill: any): void;
     /**