名将擂台：修复匹配问题

game-server/app/services/ladderService.ts

@@ -1,4 +1,4 @@
-import { ITEM_CHANGE_REASON, LADDER_OPP_STATUS, LADDER_STATUS, MAIL_TYPE, PUSH_ROUTE, REDIS_KEY } from "../consts";
+import { ITEM_CHANGE_REASON, LADDER_OPP_STATUS, LADDER_SERVER_GAP_TIME, LADDER_STATUS, MAIL_TYPE, PUSH_ROUTE, REDIS_KEY } from "../consts";
 import { HeroType } from "../db/Hero";
 import { LadderMatchModel, LadderMatchType, LadderUpdateInter } from "../db/LadderMatch";
 import { LadderMatchRecModel, LadderMatchRecType } from "../db/LadderMatchRec";
@@ -160,12 +160,14 @@ export function getNumberArr(from: number, to: number) {
     return arr;
 }
 
-function randomRank(isBefore: boolean, myRank: number, range: number, num: number, gapMin: number, gapMax: number) {
+function randomRank(isBefore: boolean, myRank: number, range: number, len: number, gapMin: number, gapMax: number) {
-    let ratio = isBefore? -1: 1;
+    if(gapMin > range) gapMin = range;
+    if(gapMax < range) gapMax = range;
     let arr: number[] = [], result = myRank;
-    while(arr.length < num) {
+    while(arr.length < len) {
-        let minMax = [ result + ratio * gapMin, result + ratio * gapMax ].sort((a, b) => a - b);
+        let min = isBefore? result - gapMax: result + gapMin;
-        let num = getRandValueByMinMax(minMax[0], minMax[1], 0);
+        let max = isBefore? result - gapMin: result + gapMax;
+        let num = getRandValueByMinMax(min, max, 0); // [min, max)
         if(isOver(isBefore, myRank, range, num)) break;
         result = num;
         arr.push(result);
@@ -176,10 +178,10 @@ function randomRank(isBefore: boolean, myRank: number, range: number, num: numbe
 // 超出匹配范围
 function isOver(isBefore: boolean, myRank: number, range: number, result: number) {
     if(isBefore) {
-        console.log('before', myRank - range < result)
+        // console.log('before', result, myRank, range, myRank - range, result < myRank - range)
         return result < myRank - range;
     } else {
-        console.log('after', myRank + range > result)
+        // console.log('after', result, myRank, range, myRank + range, result > myRank + range)
         return result > myRank + range;
     }
 }
@@ -191,14 +193,14 @@ export function checkRank(myRank: number, targetRank: number) {
         return false
     }
     if(myRank == targetRank) return false;
-    if(myRank < targetRank) { // 向后打
+    if(targetRank <= 10) {
-        if(myRank + dicLadderMatch.rangeAfterMax < targetRank) return false;
+        return dicLadderMatch.topChallenge == 1;
-    } else { // 向前打
+    } else {
-        if(myRank - dicLadderMatch.rangeBeforeMax > targetRank) return false;
+        if(myRank < targetRank) { // 向后打
-    }
+            if(myRank + dicLadderMatch.rangeAfterMax < targetRank) return false;
-
+        } else { // 向前打
-    if(targetRank <= 10 && !dicLadderMatch.topChallenge) {
+            if(myRank - dicLadderMatch.rangeBeforeMax > targetRank) return false;
-        return false
+        }    
     }
 
     return true;
@@ -278,14 +280,18 @@ function calculateDefCeByDefense(defense: LadderDefense) {
 }
 
 export async function ladderTimeout(battleCode: string, status: LADDER_STATUS) {
-    let rec = await LadderMatchRecModel.timeout(battleCode);
+    let rec = await LadderMatchRecModel.findByBattleCode(battleCode);
-    // console.log('##### rec.defenseInfo', rec.defenseInfo, rec.defenseInfo.isRobot, rec.defenseInfo.roleId)
-    if(rec.defenseInfo && !rec.defenseInfo.isRobot) await LadderMatchModel.unlock(rec.serverId, rec.defenseInfo.roleId);
     if(status == LADDER_STATUS.CHECK) {
         await sendMessageToUserWithSuc(rec.roleId1, PUSH_ROUTE.LADDER_CHECK_STOP, { battleCode });
     } else if (status == LADDER_STATUS.BATTLE) {
         await sendMessageToUserWithSuc(rec.roleId1, PUSH_ROUTE.LADDER_BATTLE_STOP, { battleCode });
     }
+
+    setTimeout(async () => {
+        let rec = await LadderMatchRecModel.timeout(battleCode);
+        // console.log('##### rec.defenseInfo', rec.defenseInfo, rec.defenseInfo.isRobot, rec.defenseInfo.roleId)
+        if(rec.defenseInfo && !rec.defenseInfo.isRobot) await LadderMatchModel.unlock(rec.serverId, rec.defenseInfo.roleId);
+    }, LADDER_SERVER_GAP_TIME * 1000);
 }
 
 /**
@@ -330,7 +336,7 @@ export async function ladderBattleEndReward(roleId: string, roleName: string, si
         let dicLadderDifficultRatio = gameData.ladderDifficultRatio.get(i);
         breakRewards.push(...(dicLadderDifficultRatio?.onceReward||[]));
     }
-    let breakGoods = breakRewards.length > 0? await addItems(roleId, roleName, sid, dicLadderDifficultRatio?.onceReward||[], ITEM_CHANGE_REASON.LADDER_BATTLE_REWARD): [];
+    let breakGoods = breakRewards.length > 0? await addItems(roleId, roleName, sid, combineItems(breakRewards), ITEM_CHANGE_REASON.LADDER_BATTLE_REWARD): [];
     return { battleGoods, breakGoods };
 }
 
@@ -381,6 +387,8 @@ export async function getLadderOppDetailData(rec: LadderMatchRecType) {
 }
 
 export async function clearLadderLock() {
-    await LadderMatchModel.clearLock();
+    let recs = await LadderMatchRecModel.clearLock();
-    await LadderMatchRecModel.clearLock();
+    for(let { serverId, defenseInfo } of recs) {
+        await LadderMatchModel.unlock(serverId, defenseInfo?.roleId);
+    }
 }

game-server/app/services/timeTaskService.ts

@@ -746,7 +746,7 @@ export async function setLadderCountDown(battleCode: string, time: number, statu
     if(scheduledJobs[`ladder${battleCode}`]) {
         scheduledJobs[`ladder${battleCode}`].cancel();
     }
-    let endTime = time + (status == LADDER_STATUS.CHECK? LADDER.LADDER_BATTLE_PREPARE_COUNTDOWN: LADDER.LADDER_BATTLE_COUNTDOWN) + LADDER_SERVER_GAP_TIME;
+    let endTime = time + (status == LADDER_STATUS.CHECK? LADDER.LADDER_BATTLE_PREPARE_COUNTDOWN: LADDER.LADDER_BATTLE_COUNTDOWN);
     scheduleJob(`ladder${battleCode}`, endTime * 1000, async () => {
         await ladderTimeout(battleCode, status);
     })

shared/db/LadderMatch.ts

@@ -103,24 +103,29 @@ export default class LadderMatch extends BaseModel {
 
         try {
     
-            let atkLadderMatch: LadderMatchType, defLadderMatch: LadderMatchType, isChange = false;
+            let newAtkLadderMatch: LadderMatchType, newDefLadderMatch: LadderMatchType, isChange = false;
             if(defenseInfo.isRobot) {
-                atkLadderMatch = await LadderMatchModel.findOne({ roleId: attackInfo.roleId }).lean();
+                let atkLadderMatch = await LadderMatchModel.findOne({ roleId: attackInfo.roleId }).lean();
                 if(isSuccess && atkLadderMatch && (atkLadderMatch.rank == 0 || atkLadderMatch.rank > defenseInfo.oldRank)) {
-                    atkLadderMatch = await LadderMatchModel.findOneAndUpdate({ roleId: attackInfo.roleId }, { $set: { rank: defenseInfo.oldRank, oldRank: atkLadderMatch.rank } }, { new: true }).lean();
+                    newAtkLadderMatch = await LadderMatchModel.findOneAndUpdate({ roleId: attackInfo.roleId }, { $set: { rank: defenseInfo.oldRank, oldRank: atkLadderMatch.rank } }, { new: true }).lean();
                     isChange = true;
+                } else {
+                    newAtkLadderMatch = atkLadderMatch;
                 }
             } else {
-                atkLadderMatch = await LadderMatchModel.findOne({ roleId: attackInfo.roleId }).lean();
+                let atkLadderMatch = await LadderMatchModel.findOne({ roleId: attackInfo.roleId }).lean();
-                defLadderMatch = await LadderMatchModel.findOne({ roleId: defenseInfo.roleId }).lean();
+                let defLadderMatch = await LadderMatchModel.findOne({ roleId: defenseInfo.roleId }).lean();
                 if(isSuccess && atkLadderMatch && defLadderMatch && (atkLadderMatch.rank == 0 || atkLadderMatch.rank > defLadderMatch.rank)) {
-                    atkLadderMatch = await LadderMatchModel.findOneAndUpdate({ roleId: attackInfo.roleId }, { $set: { rank: defLadderMatch.rank, oldRank: atkLadderMatch.rank } }, { new: true }).lean();
+                    newAtkLadderMatch = await LadderMatchModel.findOneAndUpdate({ roleId: attackInfo.roleId }, { $set: { rank: defLadderMatch.rank, oldRank: atkLadderMatch.rank } }, { new: true }).lean();
-                    defLadderMatch = await LadderMatchModel.findOneAndUpdate({ roleId: defenseInfo.roleId }, { $set: { rank: atkLadderMatch.rank, oldRank: defLadderMatch.rank } }, { new: true }).lean();
+                    newDefLadderMatch = await LadderMatchModel.findOneAndUpdate({ roleId: defenseInfo.roleId }, { $set: { rank: atkLadderMatch.rank, oldRank: defLadderMatch.rank } }, { new: true }).lean();
                     isChange = true;
+                } else {
+                    newAtkLadderMatch = atkLadderMatch;
+                    newDefLadderMatch = defLadderMatch;
                 }
             }
             await session.commitTransaction()
-            return { isChange, atkLadderMatch, defLadderMatch }
+            return { isChange, atkLadderMatch: newAtkLadderMatch, defLadderMatch: newDefLadderMatch }
         } catch(e) {
             return await this.changeRank(isSuccess, attackInfo, defenseInfo, times + 1);
         } finally {
@@ -130,15 +135,11 @@ export default class LadderMatch extends BaseModel {
 
     public static async updateCe(roleId: string, hid: number, ce: number) {   
         const rec: LadderMatchType = await LadderMatchModel.findOneAndUpdate(
-            { roleId }, 
+            { roleId, defense: { $exists: false } }, 
             { $set: { 'defense.heroes.$[t].ce': ce } },
             { arrayFilters: [{"t.actorId": hid}] }).lean();
         return rec
     }
-
-    public static async clearLock() {
-        await LadderMatchModel.updateMany({ locked: 1 }, { $set: { locked: 0 } })
-    }
 }
 
 export const LadderMatchModel = getModelForClass(LadderMatch);

shared/db/LadderMatchRec.ts

@@ -104,12 +104,16 @@ export default class LadderMatchRec extends BaseModel {
     }
 
     public static async clearLock() {
-        await LadderMatchRecModel.updateMany({ 
+        let recs = await LadderMatchRecModel.find({ 
             $or: [
                 { status: LADDER_STATUS.CHECK, checkTime: { $lt: nowSeconds() - LADDER.LADDER_BATTLE_PREPARE_COUNTDOWN } },
                 { status: LADDER_STATUS.BATTLE, checkTime: { $lt: nowSeconds() - LADDER.LADDER_BATTLE_COUNTDOWN } }
             ]
-         }, { $set: { status: LADDER_STATUS.COMPLETE, timeout: true } })
+         });
+        await LadderMatchRecModel.updateMany({ 
+            battleCode: { $in: recs.map(cur => cur.battleCode) }
+        }, { $set: { status: LADDER_STATUS.COMPLETE, timeout: true } });
+        return recs;
     }
 }
 

shared/resource/jsons/dic_zyz_ladderMatch.json

@@ -15,7 +15,7 @@
         "rankMin": 1,
         "rankMax": 10,
         "rangeBeforeMax": 0,
-        "rangeAfterMax": 0,
+        "rangeAfterMax": 1,
         "rangeBeforeNum": 0,
         "rangeAfterNum": 1,
         "interval": "0&0",