增加异步content以及GameEvent#toPromise，郭嘉和二张作为测试

character/shenhua.js

@@ -3952,10 +3952,15 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 					if(target.isMin()) return false;
 					return player!=target&&target.canEquip(card);
 				},
-				content:function(){
+				content2:function(){
 					target.equip(cards[0]);
 					player.draw();
 				},
+				async content(event, trigger, player){
+					await event.target.promises.equip(event.cards[0]);
+					game.log('老子装完了，还没摸牌')
+					await player.promises.draw();
+				},
 				discard:false,
 				lose:false,
 				prepare:function(cards,player,targets){

character/standard.js

@@ -588,7 +588,7 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 				filter:function(event){
 					return (event.num>0)
 				},
-				content:function(){
+				content2:function(){
 					'step 0'
 					event.count=trigger.num;
 					'step 1'
@@ -659,6 +659,79 @@ game.import('character',function(lib,game,ui,get,ai,_status){
 						event.goto(1);
 					}
 				},
+				async content(event, trigger, player) {
+					console.log('step 0');
+					event.count = trigger.num;
+					while (event.count > 0) {
+						console.log('step 1');
+						event.count--;
+						const { cards } = await game.cardsGotoOrdering(get.cards(2)).toPromise();
+						if (_status.connectMode) game.broadcastAll(function () { _status.noclearcountdown = true });
+						event.given_map = {};
+
+						if (!cards.length) return event.finish();
+						do {
+							console.log('step 2');
+							const { result: { bool, links } } =
+								cards.length == 1 ?
+									{ result: { links: cards.slice(0), bool: true } } :
+									await player.promises.chooseCardButton('遗计：请选择要分配的牌', true, cards, [1, cards.length])
+										.set('ai', function (button) {
+											if (ui.selected.buttons.length == 0) return 1;
+											return 0;
+										});
+							if (!bool) return event.finish();
+							console.log('step 3');
+							cards.removeArray(links);
+							event.togive = links.slice(0);
+							const { result: { targets } } = await player.promises.chooseTarget('选择一名角色获得' + get.translation(links), true)
+								.set('ai', function (target) {
+									var att = get.attitude(_status.event.player, target);
+									if (_status.event.enemy) {
+										return -att;
+									}
+									else if (att > 0) {
+										return att / (1 + target.countCards('h'));
+									}
+									else {
+										return att / 100;
+									}
+								})
+								.set('enemy', get.value(event.togive[0], player, 'raw') < 0);
+							console.log('step 4');
+							if (targets.length) {
+								const id = targets[0].playerid,
+									map = event.given_map;
+								if (!map[id]) map[id] = [];
+								map[id].addArray(event.togive);
+							}
+						} while (cards.length > 0);
+						console.log('step 5');
+						if (_status.connectMode) {
+							game.broadcastAll(function () { delete _status.noclearcountdown; game.stopCountChoose() });
+						}
+						const list = [];
+						for (const i in event.given_map) {
+							const source = (_status.connectMode ? lib.playerOL : game.playerMap)[i];
+							player.line(source, 'green');
+							list.push([source, event.given_map[i]]);
+						}
+						await game.loseAsync({
+							gain_list: list,
+							giver: player,
+							animate: 'draw',
+						}).setContent('gaincardMultiple').toPromise();
+						console.log('step 6');
+						if (event.count > 0 && player.hasSkill(event.name) && !get.is.blocked(event.name, player)) {
+							const { result: { bool: repeat } } = await player.promises.chooseBool(get.prompt2(event.name)).set('frequentSkill', event.name);
+							console.log('step 7');
+							if (repeat) {
+								player.logSkill(event.name);
+							}
+						}
+						else return event.finish();
+					}
+				},
 				ai:{
 					maixie:true,
 					maixie_hp:true,

game/game.js

@@ -47,6 +47,7 @@ new Promise(resolve=>{
 		}
 	}
 	const GeneratorFunction=(function*(){}).constructor;
+	const AsyncFunction=(async function(){}).constructor;
 	// gnc: GeNCoroutine
 	const gnc={
 		of:fn=>gnc.is.generatorFunc(fn)?function genCoroutine(){
@@ -21030,6 +21031,22 @@ new Promise(resolve=>{
 					};
 					player.queueCount=0;
 					player.outCount=0;
+					/**
+					 * 这部分应该用d.ts写。目前只给出大概类型
+					 * @type { {[key in keyof Player]: (...args) => Promise<GameEvent> & GameEvent} }
+					 */
+					player.promises=new Proxy({},{
+						get(target,prop){
+							const eventKeys=Object.keys(lib.element.player).filter(key=>typeof lib.element.player[key]=='function');
+							if (eventKeys.includes(prop)){
+								return function (...args) {
+									/** @type { GameEvent } */
+									const event=player[prop](...args);
+									return event.toPromise();
+								};
+							}
+						}
+					});
 				}
 				buildEventListener(noclick){
 					let player = this;
@@ -31288,6 +31305,14 @@ new Promise(resolve=>{
 					this._notrigger=[];
 					this._result={};
 					this._set=[];
+					/** 
+					 * @type {boolean} 这个事件是否使用异步函数处理 
+					 **/
+					this.async=false;
+					/**
+					 * @type {null|(event: GameEvent)=>any} 这个异步事件对应Promise的resolve函数
+					 **/
+					this.resolve=null;
 					if(trigger!==false&&!game.online) this._triggered=0;
 				}
 				static initialGameEvent(){
@@ -31517,7 +31542,10 @@ new Promise(resolve=>{
 					switch(typeof item){
 						case "object":
 						case "function":
-							this.content=lib.init.parsex(item);
+							if(item instanceof AsyncFunction){
+								this.content=item;
+							}
+							else this.content=lib.init.parsex(item);
 							break;
 						default:
 							try{
@@ -32073,6 +32101,87 @@ new Promise(resolve=>{
 					this.unreal;
 					throw new Error('Do not call this method');
 				}
+				/**
+				 * 事件转为Promise化
+				 * 
+				 * 注: 该函数在async content中执行时，必须在所有setxx函数执行后执行。
+				 * @returns { Promise<GameEvent> & GameEvent }
+				 */
+				toPromise(){
+					if(this.async&&this.resolve){
+						throw new TypeError('This event has been converted into a promise');
+					}
+					return new lib.element.GameEventPromise(this);
+				}
+			},
+			GameEventPromise:class extends Promise{
+				// 我谢谢你，这里是必须有的
+				static get [Symbol.species]() { 
+					return Promise;
+				}
+				/**
+				 * @param { GameEvent } event 
+				 * @returns { Promise<GameEvent> & GameEvent }
+				 */
+				constructor(event){
+					super(resolve=>{
+						// 设置为异步事件
+						event.async=true;
+						// 事件结束后触发resolve
+						event.resolve=resolve;
+						//如果父级事件也是一个异步的话，那应该立即执行这个事件的
+						if(_status.event.next.includes(event)&&_status.event.content instanceof AsyncFunction){
+							// console.log(event, '的父级事件也是一个异步,立即执行这个事件');
+							if (_status.event != event) {
+								event.parent = _status.event;
+								_status.event = event;
+								game.getGlobalHistory('everything').push(event);
+							}
+							game.loop(event);
+						}
+					});
+					return new Proxy(this,{
+						get(target,prop,receiver){
+							const thisValue=Reflect.get(target,prop);
+							if(thisValue){
+								if(typeof thisValue=='function') {
+									return thisValue.bind(target);
+								}
+								return thisValue;
+							}
+							const eventValue=Reflect.get(event,prop);
+							// 返回值如果是event，则修改为GameEventPromise
+							if(typeof eventValue=='function') return (function(...args){
+								const returnValue=eventValue.call(event,...args);
+								return returnValue==event?receiver:returnValue;
+							}).bind(event);
+							return eventValue;
+						},
+						set(target,prop,newValue){
+							return Reflect.set(event,prop,newValue);
+						},
+						deleteProperty(target,prop){
+							return Reflect.set(event,prop);
+						},
+						defineProperty(target,prop,attributes){
+							return Reflect.defineProperty(event,prop,attributes);
+						},
+						has(target,prop){
+							return Reflect.has(event,prop);
+						},
+						ownKeys(target,prop){
+							return Reflect.ownKeys(event,prop);
+						},
+					});
+				}
+				/**
+				 * TODO: 实现debugger
+				 */
+				async debugger(){
+					return new Promise(resolve=>{
+						resolve(null);
+					});
+				}
 			},
 			Dialog:class extends HTMLDivElement{
 				constructor(){
@@ -41263,217 +41372,222 @@ new Promise(resolve=>{
 				setTimeout(game.reload,15000)
 			}
 		},
-		loop:function(){
+		/**
-			while(true){
+		 * @param { GameEvent } [belongAsyncEvent]
-				var event=_status.event;
+		 */
-				var step=event.step;
+		loop:function(belongAsyncEvent){
-				var source=event.source;
+			if(belongAsyncEvent){
-				var player=event.player;
+				game.belongAsyncEvent=belongAsyncEvent;
-				var target=event.target;
+			}else if(game.belongAsyncEvent){
-				var targets=event.targets;
+				return game.loop(game.belongAsyncEvent);
-				var card=event.card;
+			}
-				var cards=event.cards;
+			return new Promise(async resolve=>{
-				var skill=event.skill;
+				while(true){
-				var forced=event.forced;
+					let event = (belongAsyncEvent && belongAsyncEvent.parent == _status.event) ? belongAsyncEvent : _status.event;
-				var num=event.num;
+					let { step, source, player, target, targets, card, cards, skill, forced, num, _trigger: trigger, _result: result } = event;
-				var trigger=event._trigger;
+					const _resolve=()=>{
-				var result=event._result;
+						if(event.async){
-				if(_status.paused2||_status.imchoosing){
+							if(typeof event.resolve=='function'){
-					if(!lib.status.dateDelaying){
+								event.resolve(event);
-						lib.status.dateDelaying=new Date();
+							}else{
+								throw new TypeError('异步事件的event.resolve未赋值，使用await时将会被永久等待');
+							}
+						}
+					};
+					if(_status.paused2||_status.imchoosing){
+						if(!lib.status.dateDelaying){
+							lib.status.dateDelaying=new Date();
+						}
 					}
-				}
+					if(_status.paused||_status.paused2||_status.over){
-				if(_status.paused||_status.paused2||_status.over){
+						return;
-					return;
-				}
-				if(_status.paused3){
-					_status.paused3='paused';
-					return;
-				}
-				if(lib.status.dateDelaying){
-					lib.status.dateDelayed+=lib.getUTC(new Date())-lib.getUTC(lib.status.dateDelaying);
-					delete lib.status.dateDelaying;
-				}
-				if(event.next.length>0){
-					var next=event.next.shift();
-					if(next.player&&next.player.skipList.contains(next.name)){
-						event.trigger(next.name+'Skipped');
-						next.player.skipList.remove(next.name);
-						if(lib.phaseName.contains(next.name)) next.player.getHistory('skipped').add(next.name);
 					}
-					else{
+					if(_status.paused3){
-						next.parent=event;
+						_status.paused3='paused';
-						_status.event=next;
+						return;
-						game.getGlobalHistory('everything').push(next);
 					}
-				}
+					if(lib.status.dateDelaying){
-				else if(event.finished){
+						lib.status.dateDelayed+=lib.getUTC(new Date())-lib.getUTC(lib.status.dateDelaying);
-					if(event._triggered==1){
+						delete lib.status.dateDelaying;
-						if(event.type=='card') event.trigger('useCardToOmitted');
-						event.trigger(event.name+'Omitted');
-						event._triggered=4;
 					}
-					else if(event._triggered==2){
+					if (belongAsyncEvent) {
-						if(event.type=='card') event.trigger('useCardToEnd');
+						console.log('-----------------------');
-						event.trigger(event.name+'End');
+						console.log(event);
-						event._triggered=3;
+						console.log('event.finished', event.finished);
+						console.log('event.after:', [...event.after]);
+						console.log('event.next:', [...event.next]);
 					}
-					else if(event._triggered==3){
+					if(event.next.length>0){
-						if(event.type=='card') event.trigger('useCardToAfter');
+						var next=event.next.shift();
-						event.trigger(event.name+'After');
-						event._triggered++;
-					}
-					else if(event.after&&event.after.length){
-						var next=event.after.shift();
 						if(next.player&&next.player.skipList.contains(next.name)){
 							event.trigger(next.name+'Skipped');
 							next.player.skipList.remove(next.name);
-							if(lib.phaseName.contains(next.name)) next.player.getHistory('skipped').add(next.name)
+							if(lib.phaseName.contains(next.name)) next.player.getHistory('skipped').add(next.name);
 						}
 						else{
 							next.parent=event;
 							_status.event=next;
+							game.getGlobalHistory('everything').push(next);
 						}
 					}
-					else{
+					else if(event.finished){
-						if(event.parent){
+						if(event._triggered==1){
-							if(event.result){
+							if(event.type=='card') event.trigger('useCardToOmitted');
-								event.parent._result=event.result;
+							event.trigger(event.name+'Omitted');
-							}
+							event._triggered=4;
-							_status.event=event.parent;
 						}
-						else{
+						else if(event._triggered==2){
-							return;
+							if(event.type=='card') event.trigger('useCardToEnd');
+							event.trigger(event.name+'End');
+							event._triggered=3;
 						}
-					}
+						else if(event._triggered==3){
-				}
+							if(event.type=='card') event.trigger('useCardToAfter');
-				else{
+							event.trigger(event.name+'After');
-					if(event._triggered==0){
-						if(event.type=='card') event.trigger('useCardToBefore');
-						event.trigger(event.name+'Before');
-						event._triggered++;
-					}
-					else if(event._triggered==1){
-						if(event.type=='card') event.trigger('useCardToBegin');
-						event.trigger(event.name+'Begin');
-						event._triggered++;
-						/*if(event.name=='phase'&&!event._begun){
-							var next=game.createEvent('phasing',false,event);
-							next.player=event.player;
-							next.skill=event.skill;
-							next.setContent('phasing');
-							event._begun=true;
-						}
-						else{
-							event.trigger(event.name+'Begin');
 							event._triggered++;
-						}*/
-					}
-					else{
-						event.callHandler(event.getDefaultHandlerType(),event,{
-							state:'begin'
-						});
-						if(player&&player.classList.contains('dead')&&!event.forceDie&&event.name!='phaseLoop'){
-							game.broadcastAll(function(){
-								while(_status.dieClose.length){
-									_status.dieClose.shift().close();
-								}
-							});
-							if(event._oncancel){
-								event._oncancel();
-							}
-							event.finish();
 						}
-						else if(player&&player.removed&&event.name!='phaseLoop'){
+						else if(event.after&&event.after.length){
-							event.finish();
+							var next=event.after.shift();
-						}
+							if(next.player&&next.player.skipList.contains(next.name)){
-						else if(player&&player.isOut()&&event.name!='phaseLoop'&&!event.includeOut){
+								event.trigger(next.name+'Skipped');
-							if(event.name=='phase'&&player==_status.roundStart&&!event.skill){
+								next.player.skipList.remove(next.name);
-								_status.roundSkipped=true;
+								if(lib.phaseName.contains(next.name)) next.player.getHistory('skipped').add(next.name)
+							}
+							else{
+								next.parent=event;
+								_status.event=next;
 							}
-							event.finish();
 						}
 						else{
-							if(_status.withError||lib.config.compatiblemode||(_status.connectMode&&!lib.config.debug)){
+							if(event.parent){
-								try{
+								if(event.result){
-									if(event.content instanceof GeneratorFunction){
+									event.parent._result=event.result;
-										if(!event.debugging){
-											if(event.generatorContent) event.generatorContent.return();
-											event.generatorContent=event.content(event,step,source,player,target,targets,
-												card,cards,skill,forced,num,trigger,result,
-												_status,lib,game,ui,get,ai);
-										}else{
-											delete event.debugging;
-										}
-										var next=event.generatorContent.next();
-										if(typeof next.value=='function'&&next.value.toString()=='code=>eval(code)'){
-											//触发debugger
-											var inputCallback=inputResult=>{
-												if(inputResult===false){
-													event.debugging=true;
-													game.resume2();
-												}else{
-													alert(get.stringify(next.value(inputResult)));
-													game.prompt('','debugger调试',inputCallback);
-												}
-											}
-											game.prompt('','debugger调试',inputCallback);
-											return game.pause2();
-										}
-										if(event.finished) event.generatorContent.return();
-									}else{
-										event.content(event,step,source,player,target,targets,
-											card,cards,skill,forced,num,trigger,result,
-											_status,lib,game,ui,get,ai);
-									}
 								}
-								catch(e){
+								_status.event=event.parent;
-									game.print('游戏出错：'+event.name);
+								if(game.belongAsyncEvent==event){
-									game.print(e.toString());
+									delete game.belongAsyncEvent;
-									console.log(e);
+									resolve();
+								}
+								_resolve();
+								// 此时应该退出了
+								if (belongAsyncEvent && belongAsyncEvent.parent == _status.event){
+									return;
 								}
 							}
 							else{
-								if(event.content instanceof GeneratorFunction){
+								if(game.belongAsyncEvent==event){
-									if(!event.debugging){
+									delete game.belongAsyncEvent;
-										if(event.generatorContent) event.generatorContent.return();
+									resolve();
-										event.generatorContent=event.content(event,step,source,player,target,targets,
-											card,cards,skill,forced,num,trigger,result,
-											_status,lib,game,ui,get,ai);
-									}else{
-										delete event.debugging;
-									}
-									var next=event.generatorContent.next();
-									if(typeof next.value=='function'&&next.value.toString()=='code=>eval(code)'){
-										//触发debugger
-										var inputCallback=inputResult=>{
-											if(inputResult===false){
-												event.debugging=true;
-												game.resume2();
-											}else{
-												alert(get.stringify(next.value(inputResult)));
-												game.prompt('','debugger调试',inputCallback);
-											}
-										}
-										game.prompt('','debugger调试',inputCallback);
-										return game.pause2();
-									}
-									if(event.finished) event.generatorContent.return();
-								}else{
-									event.content(event,step,source,player,target,targets,
-										card,cards,skill,forced,num,trigger,result,
-										_status,lib,game,ui,get,ai);
 								}
+								return _resolve();
+							}
+						}
+					}
+					else{
+						if(event._triggered==0){
+							if(event.type=='card') event.trigger('useCardToBefore');
+							event.trigger(event.name+'Before');
+							event._triggered++;
+						}
+						else if(event._triggered==1){
+							if(event.type=='card') event.trigger('useCardToBegin');
+							event.trigger(event.name+'Begin');
+							event._triggered++;
+						}
+						else{
+							event.callHandler(event.getDefaultHandlerType(),event,{
+								state:'begin'
+							});
+							const after=()=>{
+								event.clearStepCache();
+								event.callHandler(event.getDefaultHandlerType(),event,{
+									state:'end'
+								});
+								if(typeof event.step=="number") ++event.step;
+							};
+							if(player&&player.classList.contains('dead')&&!event.forceDie&&event.name!='phaseLoop'){
+								game.broadcastAll(function(){
+									while(_status.dieClose.length){
+										_status.dieClose.shift().close();
+									}
+								});
+								if(event._oncancel){
+									event._oncancel();
+								}
+								event.finish();
+								after();
+							}
+							else if(player&&player.removed&&event.name!='phaseLoop'){
+								event.finish();
+								after();
+							}
+							else if(player&&player.isOut()&&event.name!='phaseLoop'&&!event.includeOut){
+								if(event.name=='phase'&&player==_status.roundStart&&!event.skill){
+									_status.roundSkipped=true;
+								}
+								event.finish();
+								after();
+							}
+							else{
+								await game.runContent(belongAsyncEvent).catch(e=>{
+									if(_status.withError||lib.config.compatiblemode||(_status.connectMode&&!lib.config.debug)){
+										game.print('游戏出错：'+event.name);
+										game.print(e.toString());
+										console.log(e);
+									}
+									else throw e;
+								}).then(after);
 							}
 						}
-						event.clearStepCache();
-						event.callHandler(event.getDefaultHandlerType(),event,{
-							state:'end'
-						});
-						if(typeof event.step=="number") ++event.step;
 					}
 				}
-			}
+			});
+		},
+		runContent(belongAsyncEvent) {
+			return new Promise(resolve=>{
+				let event = (belongAsyncEvent && belongAsyncEvent.parent == _status.event) ? belongAsyncEvent : _status.event;
+				let { step, source, player, target, targets, card, cards, skill, forced, num, _trigger: trigger, _result: result } = event;
+				if (event.content instanceof GeneratorFunction) {
+					if (!event.debugging) {
+						if (event.generatorContent) event.generatorContent.return();
+						event.generatorContent = event.content(event, step, source, player, target, targets,
+							card, cards, skill, forced, num, trigger, result,
+							_status, lib, game, ui, get, ai);
+					} else {
+						delete event.debugging;
+					}
+					var next = event.generatorContent.next();
+					if (typeof next.value == 'function' && next.value.toString() == 'code=>eval(code)') {
+						//触发debugger
+						var inputCallback = inputResult => {
+							if (inputResult === false) {
+								event.debugging = true;
+								game.resume2();
+							} else {
+								alert(get.stringify(next.value(inputResult)));
+								game.prompt('', 'debugger调试', inputCallback);
+							}
+						}
+						game.prompt('', 'debugger调试', inputCallback);
+						return game.pause2();
+					}
+					if (event.finished) event.generatorContent.return();
+					resolve();
+				}
+				else if (event.content instanceof AsyncFunction) {
+					// _status,lib,game,ui,get,ai六个变量由game.import提供
+					event.content(event, trigger, player).then(() => {
+						event.finish();
+						resolve();
+					});
+				}
+				else {
+					event.content(event, step, source, player, target, targets,
+						card, cards, skill, forced, num, trigger, result,
+						_status, lib, game, ui, get, ai);
+					resolve();
+				}
+			});
 		},
 		pause:function(){
 			clearTimeout(_status.timeout);