名将擂台：修改重启后对数据接续处理

game-server/app/servers/battle/handler/ladderHandler.ts

@@ -116,7 +116,7 @@ export class LadderHandler {
         let roleId = session.get('roleId');
         let { battleCode } = msg;
         // 更新ladderMatchRec
-        let rec = await LadderMatchRecModel.giveup(battleCode);
+        let rec = await LadderMatchRecModel.giveup(roleId, battleCode);
         if(rec) {
             pinus.app.rpc.systimer.systimerRemote.cancelLadderCountDown.broadcast(rec.battleCode);
             if(rec.defenseInfo && !rec.defenseInfo.isRobot) await LadderMatchModel.unlock(rec.serverId, rec.defenseInfo.roleId);
@@ -374,27 +374,19 @@ export class LadderHandler {
 
         let roleId = session.get('roleId');
 
-        let ladderData = await LadderMatchModel.findByRoleId(roleId);
+        let atkLadderMatch = await LadderMatchModel.findByRoleId(roleId);
-        if(!ladderData || !ladderData.defense) return resResult(STATUS.LADDER_NOT_OPEN);
+        if(!atkLadderMatch || !atkLadderMatch.defense) return resResult(STATUS.LADDER_NOT_OPEN);
 
-        let defenseInfo: { isRobot: boolean, roleId: string, oldRank: number };
+        let defLadderMatch = await LadderMatchModel.findByRank(rank);
-        let hisLadderData = await LadderMatchModel.findByRank(rank);
+        if(defLadderMatch) {
-        if(hisLadderData) {
+            atkLadderMatch = await LadderMatchModel.findOneAndUpdate({ roleId }, { $set: { rank, oldRank: atkLadderMatch.rank, historyRank: rank } }, { new: true }).lean();
-            defenseInfo = { isRobot: false, roleId: hisLadderData.roleId, oldRank: hisLadderData.rank };
+            defLadderMatch = await LadderMatchModel.findOneAndUpdate({ roleId: defLadderMatch.roleId }, { $set: { rank: atkLadderMatch.rank, oldRank: defLadderMatch.rank } }, { new: true }).lean();
-        } else {
+        } else {                    
-            defenseInfo = { isRobot: true, roleId: `robot${rank}`, oldRank: rank };
+            atkLadderMatch = await LadderMatchModel.findOneAndUpdate({ roleId }, { $set: { rank, oldRank: atkLadderMatch.rank, historyRank: rank } }, { new: true }).lean();
         }
 
-        let result = new LadderDataReturn();
+        await battleEndWhenChange(atkLadderMatch, true);
-        // 交换双方排名， transaction
+        await battleEndWhenChange(defLadderMatch, true);
-        let { isChange, atkLadderMatch, defLadderMatch } = await LadderMatchModel.changeRank(true, { roleId }, defenseInfo);
-
-        if(isChange) {
-            let oppPlayers = await battleEndWhenChange(atkLadderMatch, true);
-            await battleEndWhenChange(defLadderMatch, true);
-            result.setOppPlayers(oppPlayers);
-        }
-        ladderData = await LadderMatchModel.updateByRoleId(roleId, { historyRank: rank });
         return resResult(STATUS.SUCCESS);
     }
 

game-server/app/services/ladderService.ts

@@ -384,10 +384,3 @@ export async function getLadderOppDetailData(rec: LadderMatchRecType) {
     }
     return result;
 }
-
-export async function clearLadderLock() {
-    let recs = await LadderMatchRecModel.clearLock();
-    for(let { serverId, defenseInfo } of recs) {
-        await LadderMatchModel.unlock(serverId, defenseInfo?.roleId);
-    }
-}

game-server/app/services/timeTaskService.ts

@@ -40,7 +40,8 @@ import { checkPopUpConditionWhenGuildActivityEnd } from './activity/popUpShopSer
 import { pushRefreshTime } from './connectorService';
 import { sendUnReceivedActivityDailyCoin } from './activity/dailyCoinService';
 import { ladderTimeout, ladderTimeWillout, sendLadderDailyReward } from './ladderService';
-import { clearLadderLock } from './ladderService';
+import { LadderMatchRecModel } from '../db/LadderMatchRec';
+import { LadderMatchModel } from '../db/LadderMatch';
 
 const PER_SECOND = 1 * 1000;
 const PER_DAY = 24 * 60 * 60;
@@ -771,6 +772,25 @@ async function ladderDailyReward() {
             await sendLadderDailyReward(serverId);
         }
     });
-    await clearLadderLock();
+    let recs = await LadderMatchRecModel.getUncompleteData();
+    let battleCodes: string[] = [];
+    for(let { battleCode, checkTime, battleTime, status, serverId, defenseInfo } of recs) {
+        if(status == LADDER_STATUS.CHECK) {
+            if(Date.now() > checkTime + LADDER.LADDER_BATTLE_PREPARE_COUNTDOWN * 1000) {
+                battleCodes.push(battleCode);
+                await LadderMatchModel.unlock(serverId, defenseInfo?.roleId);
+            } else {
+                await setLadderCountDown(battleCode, checkTime, status)
+            }
+        } else if (status == LADDER_STATUS.BATTLE) {
+            if(Date.now() > battleTime + LADDER.LADDER_BATTLE_COUNTDOWN * 1000 ) {
+                battleCodes.push(battleCode);
+                await LadderMatchModel.unlock(serverId, defenseInfo?.roleId);
+            } else {
+                await setLadderCountDown(battleCode, battleTime, status)
+            }
+        }
+    }
+    await LadderMatchRecModel.timeoutMany(battleCodes);
 }
 // —————————————— 名将擂台 end —————————————— //

shared/db/LadderMatchRec.ts

@@ -20,6 +20,8 @@ export default class LadderMatchRec extends BaseModel {
     @prop({ required: true })
     timeout: boolean;					// 是否超时
     @prop({ required: true })
+    giveup: boolean;					// 是否取消
+    @prop({ required: true })
     checkTime: number;					// 开始出兵的时间，13位时间戳
     @prop({ required: true })
     battleTime: number;				// 开始挑战的时间，13位时间
@@ -55,8 +57,8 @@ export default class LadderMatchRec extends BaseModel {
         return result;
     }
 
-    public static async giveup(battleCode: string) {
+    public static async giveup(roleId: string, battleCode: string) {
-        const result: LadderMatchRecType = await LadderMatchRecModel.findOneAndUpdate({ battleCode }, { $set: { status: LADDER_STATUS.NO } }, { new: true }).lean();
+        const result: LadderMatchRecType = await LadderMatchRecModel.findOneAndUpdate({ roleId1: roleId, battleCode }, { $set: { status: LADDER_STATUS.COMPLETE, timeout: false, giveup: true, endTime: Date.now() } }, { new: true }).lean();
         return result;
     }
 
@@ -102,18 +104,23 @@ export default class LadderMatchRec extends BaseModel {
         return result;
     }
 
-    public static async clearLock() {
+    public static async getUncompleteData() {
         let recs = await LadderMatchRecModel.find({ 
             $or: [
-                { status: LADDER_STATUS.CHECK, checkTime: { $lt: Date.now() - LADDER.LADDER_BATTLE_PREPARE_COUNTDOWN * 1000 } },
+                { status: LADDER_STATUS.CHECK },
-                { status: LADDER_STATUS.BATTLE, checkTime: { $lt: Date.now() - LADDER.LADDER_BATTLE_COUNTDOWN * 1000 } }
+                { status: LADDER_STATUS.BATTLE }
             ]
          });
-        await LadderMatchRecModel.updateMany({ 
-            battleCode: { $in: recs.map(cur => cur.battleCode) }
-        }, { $set: { status: LADDER_STATUS.COMPLETE, timeout: true } });
         return recs;
     }
+
+    public static async timeoutMany(battleCode: string[]) {
+        
+        await LadderMatchRecModel.updateMany({ 
+            battleCode: { $in: battleCode }
+        }, { $set: { status: LADDER_STATUS.COMPLETE, timeout: true, endTime: Date.now() } });
+
+    }
 }
 
 export const LadderMatchRecModel = getModelForClass(LadderMatchRec);