名将擂台：获取对手详细信息，结算

shared/db/LadderMatch.ts

@@ -1,6 +1,6 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType, mongoose, Ref } from '@typegoose/typegoose';
-import { LadderDefense, LadderOppPlayerInDB } from '../domain/battleField/ladder';
+import { LadderDefense, LadderOppPlayerInDB, LadderOppPlayerInfo } from '../domain/battleField/ladder';
 import Role from './Role';
 
 @index({ roleId: 1 })
@@ -14,6 +14,8 @@ export default class LadderMatch extends BaseModel {
     @prop({ required: true, default: 0 })
     rank: number;				    // 排名
     @prop({ required: true, default: 0 })
+    oldRank: number;				 // 交换前排名
+    @prop({ required: true, default: 0 })
     historyRank: number;		    // 历史最高排名
 
     @prop({ required: true, default: 0 })
@@ -66,10 +68,17 @@ export default class LadderMatch extends BaseModel {
         return defense;
     }
 
+    public static async updateByRoleIdAndInclude(roleId: string, params: LadderUpdateInter) {
+        const defense: LadderMatchType = await LadderMatchModel.findOneAndUpdate({ roleId }, { $set: params}, { new: true })
+        .populate('role', 'roleId roleName head frame spine heads frames spines title lv updatedAt')
+        .populate('defense.hero', 'hid skinId quality star colorStar lv')
+        .lean();
+        return defense;
+    }
     public static async findAll(serverId: number) {
         let result: LadderMatchType[] = [], latestTime = new Date();
         while(latestTime) {
-            let ladderMatch = await LadderMatchModel.find({ serverId, rank: { $gt: 0 }, createdAt: { $lt: latestTime } })
+            let ladderMatch = await LadderMatchModel.find({ serverId, rank: { $gt: 0, $lte: 3000 }, createdAt: { $lt: latestTime } })
                 .sort({ createdAt: -1 })
                 .populate('role', 'roleId roleName head frame spine heads frames spines title lv updatedAt')
                 .limit(1000);
@@ -83,6 +92,27 @@ export default class LadderMatch extends BaseModel {
         const defense: LadderMatchType = await LadderMatchModel.findOneAndUpdate({ roleId, rank, locked: 0 }, { $set: { locked: 1 }}, { new: true }).lean();
         return defense;
     }
+
+    public static async changeRank(isSuccess: boolean, attackInfo: LadderOppPlayerInfo, defenseInfo: LadderOppPlayerInfo) {
+        // TODO transaction
+        let atkLadderMatch: LadderMatchType, defLadderMatch: LadderMatchType, isChange = false;
+        if(defenseInfo.isRobot) {
+            atkLadderMatch = await LadderMatchModel.findOne({ roleId: attackInfo.roleId }).lean();
+            if(isSuccess && atkLadderMatch && atkLadderMatch.rank > defenseInfo.oldRank) {
+                atkLadderMatch = await LadderMatchModel.findOneAndUpdate({ roleId: attackInfo.roleId }, { $set: { rank: defenseInfo.oldRank, oldRank: atkLadderMatch.rank } }, { new: true }).lean();
+                isChange = true;
+            }
+        } else {
+            atkLadderMatch = await LadderMatchModel.findOne({ roleId: attackInfo.roleId }).lean();
+            defLadderMatch = await LadderMatchModel.findOne({ roleId: defenseInfo.roleId }).lean();
+            if(isSuccess && atkLadderMatch && defLadderMatch && atkLadderMatch.rank > defLadderMatch.rank) {
+                atkLadderMatch = 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();
+                isChange = true;
+            }
+        }
+        return { isChange, atkLadderMatch, defLadderMatch }
+    }
 }
 
 export const LadderMatchModel = getModelForClass(LadderMatch);

shared/db/LadderMatchRec.ts

@@ -5,7 +5,7 @@ import { Defense, Attack, LineupCe, OppPlayer, HeroScore, } from '../domain/batt
 import { CounterModel } from './Counter';
 import { COUNTER, LADDER_STATUS } from '../consts';
 import { EXTERIOR, PVP } from '../pubUtils/dicParam';
-import { LadderDefense, LadderOppPlayerInfo } from '../domain/battleField/ladder';
+import { LadderDefense, LadderOppPlayerInfo, LadderOppPlayerHeroInfo } from '../domain/battleField/ladder';
 import { genCode } from '../pubUtils/util';
 import { nowSeconds } from '../pubUtils/timeUtil';
 
@@ -56,12 +56,41 @@ export default class LadderMatchRec extends BaseModel {
     }
 
     public static async timeout(battleCode: string) {
-        const result: LadderMatchRecType = await LadderMatchRecModel.findOneAndUpdate({ battleCode }, { $set: { status: LADDER_STATUS.COMPLETE, timeout: true } }).lean();
+        const result: LadderMatchRecType = await LadderMatchRecModel.findOneAndUpdate({ battleCode }, { $set: { status: LADDER_STATUS.COMPLETE, timeout: true } }, { new: true }).lean();
         return result;
     }
 
     public static async giveup(battleCode: string) {
-        const result: LadderMatchRecType = await LadderMatchRecModel.findOneAndUpdate({ battleCode }, { $set: { status: LADDER_STATUS.NO } }).lean();
+        const result: LadderMatchRecType = await LadderMatchRecModel.findOneAndUpdate({ battleCode }, { $set: { status: LADDER_STATUS.NO } }, { new: true }).lean();
+        return result;
+    }
+
+    public static async findByBattleCode(battleCode: string, select: string = '') {
+        const result: LadderMatchRecType = await LadderMatchRecModel.findOne({ battleCode }).select(select).lean();
+        return result;
+    }
+
+    public static async startBattle(battleCode: string, attackHeroes: LadderOppPlayerHeroInfo[]) {
+        const result: LadderMatchRecType = await LadderMatchRecModel.findOneAndUpdate({ battleCode }, {
+            $set: { status: LADDER_STATUS.BATTLE, battleTime: nowSeconds(), 'attackInfo.heroes': attackHeroes }
+        }, { new: true }).lean();
+        return result;
+    }
+
+    public static async battleEnd(battleCode: string, isSuccess: boolean, atkNewRank?: number, defNewRank?: number) {
+        let update: LadderMatchRecUpdate = { status: LADDER_STATUS.COMPLETE, endTime: nowSeconds() };
+        if(isSuccess) {
+            update['attackInfo.isSuccess'] = true;
+            update['defenseInfo.isSuccess'] = false;
+        }
+        if(atkNewRank != undefined && defNewRank != undefined) {
+            update['attackInfo.rank'] = atkNewRank;
+            update['attackInfo.oldRank'] = defNewRank;
+            update['defenseInfo.rank'] = defNewRank;
+            update['defenseInfo.oldRank'] = atkNewRank;
+        }
+
+        const result: LadderMatchRecType = await LadderMatchRecModel.findOneAndUpdate({ battleCode }, { $set: update }, { new: true }).lean();
         return result;
     }
 }
@@ -69,4 +98,4 @@ export default class LadderMatchRec extends BaseModel {
 export const LadderMatchRecModel = getModelForClass(LadderMatchRec);
 
 export interface LadderMatchRecType extends Pick<DocumentType<LadderMatchRec>, keyof LadderMatchRec> { };
-export type pvpUpdateInter = Partial<LadderMatchRecType>;
+export type LadderMatchRecUpdate = Partial<LadderMatchRecType>;