出卡延时处理和下随从延时处理

src/rooms/commands/SelectPetCommand.ts

@@ -108,6 +108,7 @@ export class SelectPetCommand extends Command<CardGameState, {
       dbpt_cnt,
       oldpos
     })
+    await this.delay(1000)  // 选好卡后延时1秒使用卡牌
     let time = this.room.battleMan.useCard(data)
     await this.delay(time)
     const multipEat = !!this.state.rules.get(RULE_MULTIPLEEAT)

src/rooms/logic/Handler/BattleHandler.ts

@@ -5,7 +5,7 @@ import { PlayerHandler } from "./PlayerHandler";
 import CfgMan from "../CfgMan";
 import { EffectCardType, GameCampType, GameUnitType, SkillEffectType, SkillRangeUnitType } from "../skill/SkillConst";
 import { Pet } from "rooms/schema/Pet";
-import {PetUpdateProcess, PlayerRemoveMsg, SkillParam, SkillResult, SkillTarget} from "../skill/SkillParam";
+import {PetUpdateProcess, CachePlayerRemoveMsg, SkillParam, SkillResult, SkillTarget} from "../skill/SkillParam";
 import { nosync, Room } from "colyseus";
 import { Skill } from "../skill/Skill";
 import { PetHandler } from "./PetHandler";
@@ -26,14 +26,16 @@ export class BattleHandler {
     _room: Room;
     private _flowcount: number = 0;
     private _sktime: number;
+    private _pettime: number;
     private _gamestart: boolean = false;
 
     private _usingcard: boolean = false;
     private _cacheSkills: SkillTarget[] = [];
-    private _cachePets: PetHandler[] = [];
+    private _cacheSkillMap: Map<string, SkillTarget[]> = new Map;
-    private _cacheAddPets: PetHandler[] = [];
 
-    private _cachePlayerMsgs: PlayerRemoveMsg[] = [];
+    private _cachePets: PetHandler[] = [];  // died/changed
+
+    private _cachePlayerMsgs: CachePlayerRemoveMsg[] = [];  // died
 
     private _lastlinkph: PlayerHandler;
 
@@ -491,6 +493,7 @@ export class BattleHandler {
         
         if(this._flowcount == 0){
             this._sktime = 0;
+            this._pettime = 0;
             this._cacheSkills.length = 0;
             this._cachePets.length = 0;
             this._cachePlayerMsgs.length = 0;
@@ -513,8 +516,18 @@ export class BattleHandler {
         debugRoom(`[endFlow]${step}|${res}`);
 
         if(res == 0){
-            this.handleCacheSkills();
+            let nt = this._pettime * 1000;
-            let nt = this._sktime * 1000;
+            if(nt > 0){
+                this._sktime += this.preHandleCacheSkills();
+                this._room.clock.setTimeout(()=>{
+                    this.handleCacheSkills();
+                }, nt);
+            }else{
+                this._sktime += this.preHandleCacheSkills();
+                this.handleCacheSkills();
+            }
+            
+            nt += this._sktime * 1000;
             if(this._cachePets.length > 0 || this._cachePlayerMsgs.length > 0){
                 if(nt > 0){
                     nt += 100;  // 延时100ms处理随从
@@ -529,8 +542,7 @@ export class BattleHandler {
             }
             this._flowcount = res;
             
-            // let dt = isusecard? 5000: 100;// 延时100ms开始下个步骤
+            let dt = 100; // 延时100ms开始下个步骤
-            let dt = 100;
             return nt + dt; 
         }
 
@@ -540,10 +552,112 @@ export class BattleHandler {
         return 0;
     };
 
+    public preHandleCacheSkills(){
+        let skillres = this._cacheSkills;
+        /**
+         * indexOfAttack
+        start: number: number*/
+        let __indexOfAttack = function(start: number): number {
+            for(let i = start; i < skillres.length;i++){
+                if(skillres[i].bresok && skillres[i].isAttackSkill()){
+                    return i;
+                }
+            }
+            return -1;
+        };
+
+        let __indexOfAttackBk = function(start: number, atkres: SkillTarget): number{
+            for(let i = start; i < skillres.length;i++){
+                let obj = skillres[i];
+                if(obj.bresok && obj.isAttackBackSkill() 
+                    && atkres.dst == obj.srcPet() && obj.dst == atkres.srcPet()){
+                    return i;
+                }
+            }
+            return -1;
+        };
+
+
+        if(!skillres || skillres.length <= 0){
+            return 0;
+        }
+
+        // 合并冲锋/反击
+        let nstart = 0;
+        while(true){
+            if(nstart >= skillres.length){
+                break;
+            }
+            let natk = __indexOfAttack(nstart);
+            if(natk < 0){
+                break;
+            }
+            nstart = natk + 1;
+            let atkobj = skillres[natk];
+            let natkbk = __indexOfAttackBk(nstart, atkobj);
+            if(natkbk >= 0){
+                let atkbkobj = skillres[natkbk];
+                if(!atkbkobj){
+                    console.log('[error find attakbk]'+natkbk);
+                }
+                atkbkobj.res && atkbkobj.res.forEach((item: SkillResult) => {
+                    if(item.bsuccess){
+                        if(item.effect_type == SkillEffectType.CHG_AP || item.effect_type == SkillEffectType.CHG_HP){
+                            atkobj.success(item.effect_type, item.effect_res, true);
+                        }
+                    }
+                });
+                skillres.splice(natkbk, 1);
+            }
+        }
+
+        let resmap = this._cacheSkillMap;
+        resmap.clear();
+        let lastkey = '';
+        let cnt = 0;
+        skillres.forEach((item: SkillTarget)=>{
+            let key = item.srcskillid + '|' + item.srcplayer.getId() + '|' + item.flag;
+            if(item.srcpet){
+                key += '|' + item.srcpet._idx;
+            }
+
+            if(lastkey != key && lastkey != ''){
+                cnt++;
+            }
+            lastkey = key;
+
+            let realkey = key + '|' + cnt;
+            let tmplst = resmap.get(realkey);
+            if(!tmplst){
+                tmplst = [item];
+                resmap.set(realkey, tmplst);
+            }else{
+                tmplst.push(item);
+            }
+        });
+
+        let tm = 0;
+        resmap.forEach((item: SkillTarget[]) =>{
+            let st = item[0];
+            tm += st.getLastTime();
+        });
+
+        return tm;
+    };
+
     public handleCacheSkills(){
-        if(this._cacheSkills.length > 0){
+        if(this._cacheSkillMap.size > 0){
-            this.onSkillResultNotify(this._cacheSkills);
+            let skid = '';
-            this._cacheSkills.length = 0;
+            let lst: SkillInfoMsg[] = [];
+            this._cacheSkillMap.forEach((item: SkillTarget[]) =>{
+                let st = item[0];
+                lst.push(st.exportMsg(item));
+                skid += st.srcskillid + '|';
+            });
+    
+            this._room.bMsgQueue(lst);
+
+            this._cacheSkillMap.clear();
         }
     };
 
@@ -818,7 +932,7 @@ export class BattleHandler {
             return 0;
         }
         if(this.isFlowing()){
-            let obj = this._cachePlayerMsgs.find((v: PlayerRemoveMsg)=>{
+            let obj = this._cachePlayerMsgs.find((v: CachePlayerRemoveMsg)=>{
                 return ph.getId() == v.id;
             });
             if(!obj){
@@ -856,8 +970,8 @@ export class BattleHandler {
 
 
     // --------------------调用外部接口函数--------------------------
-    public onPlayerDiedNotify(players: PlayerRemoveMsg[]){
+    public onPlayerDiedNotify(players: CachePlayerRemoveMsg[]){
-        players && players.forEach((item: PlayerRemoveMsg)=>{
+        players && players.forEach((item: CachePlayerRemoveMsg)=>{
             item.pets.forEach((pet: RemovePetMsg) =>{
                 this._room.bRemovePet(pet);
             });
@@ -865,7 +979,15 @@ export class BattleHandler {
         });
     };
 
-    public onAddPetNotify(apet: PetHandler){
+    public onAddPetNotify(apet: PetHandler, isself: boolean){
+        if(!isself){
+            if(this.isFlowing()){
+                this._pettime += 1; // 下随从延时1秒
+            }else{
+                this._room.addScheduleTime(1000, 'onAddPetNotify', 'onAddPetNotify');
+            }
+        }
+
         return this._room.bAddPet(apet.exportInfoMsg());
     };
 
@@ -926,22 +1048,22 @@ export class BattleHandler {
     };
 
     public onPlayerAddCardNotify(aplayer: PlayerHandler, count: number, maxcount: number,
-        from?: PlayerHandler): number{
+        from?: PlayerHandler, tgt?: SkillTarget): number{
         return this._room.addCard(aplayer.getId(), count, maxcount, 1, from? from.getId(): null);
     };
 
     public onPlayerStealCardNotify(srcplayer: PlayerHandler,
-        dstplayer: PlayerHandler, count: number): number{
+        dstplayer: PlayerHandler, count: number, tgt?: SkillTarget): number{
         return this._room.drawCardFromPlayer(srcplayer.getId(), dstplayer.getId(), count);
     };
 
     public onPlayerAddDirectCardNotify(aplayer: PlayerHandler, count: number, cardid: number,
-        from?: PlayerHandler){
+        from?: PlayerHandler, tgt?: SkillTarget){
             return this._room.generateCard({player: aplayer.getId(), count, effectId: cardid,
                 fromplayer: from? from.getId(): null});
     };
 
-    public onPlayerDropCardNotify(aplayer: PlayerHandler, count: number, from?: PlayerHandler): number{
+    public onPlayerDropCardNotify(aplayer: PlayerHandler, count: number, from?: PlayerHandler, tgt?: SkillTarget): number{
         return this._room.giveUpCard(aplayer.getId(), count, from? from.getId(): null);
     };
 
@@ -1003,7 +1125,6 @@ export class BattleHandler {
             }
         }
 
-        let checklst: PlayerHandler[] = [];
         let lst: SkillInfoMsg[] = [];
         let resmap: Map<string, SkillTarget[]> = new Map;
         let lastkey = '';
@@ -1036,22 +1157,10 @@ export class BattleHandler {
 
             tm += st.getLastTime();
             skid += st.srcskillid + '|';
-
-            // st.isHurtSkill() && item.forEach((v: SkillTarget)=>{
-            //     if(v.targetIsPet()){
-            //         let ph = v.targetPlayer();
-            //         if(!checklst.includes(ph)){
-            //             checklst.push(ph);
-            //         }
-            //     }
-            // })
         });
 
-        if(this.isFlowing()){
+        this._room.addScheduleTime(tm*1000, 'onSkillResultNotify', skid);
-            this._sktime += tm;
+
-        }else{
-            this._room.addScheduleTime(tm*1000, skid);
-        }
         this._room.bMsgQueue(lst);
 
         // checklst.forEach((item: PlayerHandler) => {

src/rooms/logic/Handler/PlayerHandler.ts

@@ -7,7 +7,7 @@ import { Pet } from "rooms/schema/Pet";
 import { CondDecideType, CondType, EffectCardType, GameUnitType, SkillEffectType, SkillType, SkillUserType, TriggerType } from "../skill/SkillConst";
 import { UnitCfg } from "cfg/parsers/UnitCfg";
 import { Skill } from "../skill/Skill";
-import { PlayerRemoveMsg, SkillParam, SkillTarget } from "../skill/SkillParam";
+import { CachePlayerRemoveMsg, SkillParam, SkillTarget } from "../skill/SkillParam";
 import SkillMan from "../skill/SkillMan";
 import { Card } from "rooms/schema/Card";
 import arrUtil from "utils/array.util";
@@ -303,24 +303,24 @@ export class PlayerHandler {
         return this.handleSkill(skillid, count, usertype, this._self, from._petowner, param);
     };
 
-    public addCard(count: number, from?: PlayerHandler): number{
+    public addCard(count: number, from?: PlayerHandler, tgt?: SkillTarget): number{
-        return this._owner.onPlayerAddCardNotify(this, count, 0, from);
+        return this._owner.onPlayerAddCardNotify(this, count, 0, from, tgt);
     };
 
-    public addCardLimit(maxcount: number, from?: PlayerHandler): number{
+    public addCardLimit(maxcount: number, from?: PlayerHandler, tgt?: SkillTarget): number{
-        return this._owner.onPlayerAddCardNotify(this, 0, maxcount, from);
+        return this._owner.onPlayerAddCardNotify(this, 0, maxcount, from, tgt);
     };
 
-    public addDirectCard(cardid: number, count: number, from?: PlayerHandler){
+    public addDirectCard(cardid: number, count: number, from?: PlayerHandler, tgt?: SkillTarget){
-        return this._owner.onPlayerAddDirectCardNotify(this, count, cardid, from);
+        return this._owner.onPlayerAddDirectCardNotify(this, count, cardid, from, tgt);
     };
 
-    public stealCard(dstplayer: PlayerHandler, count: number): number{
+    public stealCard(dstplayer: PlayerHandler, count: number, tgt?: SkillTarget): number{
-        return this._owner.onPlayerStealCardNotify(this, dstplayer, count);
+        return this._owner.onPlayerStealCardNotify(this, dstplayer, count, tgt);
     };
 
-    public dropCard(count: number, from?: PlayerHandler): number{
+    public dropCard(count: number, from?: PlayerHandler, tgt?: SkillTarget): number{
-        return this._owner.onPlayerDropCardNotify(this, count, from);
+        return this._owner.onPlayerDropCardNotify(this, count, from, tgt);
     };
 
     public addHP(value: number, from: PetHandler): number{
@@ -426,7 +426,7 @@ export class PlayerHandler {
     };
 
     public onPetBorned(apet: PetHandler, param: SkillParam){
-        this._owner.onAddPetNotify(apet);
+        this._owner.onAddPetNotify(apet, apet == this._self);
         this.onEMChanged(apet._enmagic);//增加法强
         // 战吼
         if(!apet.isSilent()){
@@ -883,7 +883,7 @@ export class PlayerHandler {
         return this._self? this._self.delBuff(buffid, buffcount, from): -1;
     };
 
-    public exportRemoveMsg(): PlayerRemoveMsg{
+    public exportRemoveMsg(): CachePlayerRemoveMsg{
-        return new PlayerRemoveMsg(this);
+        return new CachePlayerRemoveMsg(this);
     };
 }

src/rooms/logic/skill/Skill.ts

@@ -392,7 +392,7 @@ export class Skill {
         switch(efftype){
             case SkillEffectType.CARD_ADD:
                 if(tgt.dsttype == GameUnitType.PLAYER){
-                    let n = (tgt.dst as PlayerHandler).addCard(res, tgt.srcPlayer());
+                    let n = (tgt.dst as PlayerHandler).addCard(res, tgt.srcPlayer(), tgt);
                     if(n >= 0){
                         tgt.success(efftype, n);
                     }else{
@@ -404,7 +404,7 @@ export class Skill {
                 break;
             case SkillEffectType.CARD_ADD_LIMIT:
                 if(tgt.dsttype == GameUnitType.PLAYER){
-                    let n = (tgt.dst as PlayerHandler).addCardLimit(res, tgt.srcPlayer());
+                    let n = (tgt.dst as PlayerHandler).addCardLimit(res, tgt.srcPlayer(), tgt);
                     if(n >= 0){
                         tgt.success(efftype, n);
                     }else{
@@ -416,7 +416,7 @@ export class Skill {
                 break;
             case SkillEffectType.CARD_STEAL:
                 if(tgt.dsttype == GameUnitType.PLAYER){
-                    let n = tgt.srcplayer.stealCard((tgt.dst as PlayerHandler), res);
+                    let n = tgt.srcplayer.stealCard((tgt.dst as PlayerHandler), res, tgt);
                     if(n >= 0){
                         tgt.success(efftype, n);
                     }else{
@@ -434,7 +434,7 @@ export class Skill {
                     let cardid = this._data.quotecardid;
                     let ncount = this.getQuoteValue(this._data.quotecard_times, this._data.quotecard_timesmax, this._orign_effcnt);
 
-                    let n = (tgt.dst as PlayerHandler).addDirectCard(cardid, ncount, tgt.srcPlayer());
+                    let n = (tgt.dst as PlayerHandler).addDirectCard(cardid, ncount, tgt.srcPlayer(), tgt);
                     if(n >= 0){
                         tgt.success(efftype, n);
                     }else{
@@ -447,7 +447,7 @@ export class Skill {
             case SkillEffectType.CARD_DROP:
                 {
                     if(tgt.dsttype == GameUnitType.PLAYER){
-                        let n = (tgt.dst as PlayerHandler).dropCard(res, tgt.srcPlayer());
+                        let n = (tgt.dst as PlayerHandler).dropCard(res, tgt.srcPlayer(), tgt);
                         if(n >= 0){
                             tgt.success(efftype, n);
                         }else{

src/rooms/logic/skill/SkillParam.ts

@@ -404,7 +404,7 @@ export class PetUpdateProcess{
     };
 };
 
-export class PlayerRemoveMsg{
+export class CachePlayerRemoveMsg{
     id: string;
     pets: RemovePetMsg[];
     constructor(player: PlayerHandler){
@@ -414,4 +414,8 @@ export class PlayerRemoveMsg{
             this.pets.push(item.exportRemoveMsg());
         });
     }
-}
+};
+
+export class CacheCardMsg{
+
+};