pvp测试debug

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

@@ -19,7 +19,7 @@ import { PvpRecordModel, HeroesRecord } from '../../../db/PvpRecord';
 import { existsRank, initRank, getRank, setRank, getMyRank } from '../../../services/redisService';
 import { handleCost } from '../../../services/rewardService';
 import { nowSeconds } from '../../../pubUtils/timeUtil';
-
+import { setPvpSeasonResult, resetPvpWarId } from '../../../services/timeTaskService';
 export default function(app: Application) {
     return new PvpHandler(app);
 }
@@ -51,6 +51,16 @@ export class PvpHandler {
 
     }
 
+    async debugPvpSeasonReset(msg: {}, session: BackendSession) {
+        let { seasonNum, seasonEndTime } = await setPvpSeasonResult({name: 'exce setPvpSeasonResult debug'});
+        return resResult(STATUS.SUCCESS, { seasonNum, seasonEndTime })
+    }
+
+    async debugPvpWarReset(msg: {}, session: BackendSession) {
+        let systemConfig = await resetPvpWarId();
+        return resResult(STATUS.SUCCESS, {systemConfig});
+    }
+
     async getData (msg: {}, session: BackendSession) {
         let roleId = session.get('roleId');
         let {pvpDefense, warId} = await findPvpDefAllByRoleId(roleId);
@@ -261,7 +271,7 @@ export class PvpHandler {
 
         if (!!isDefaultHero) {
             let role = await RoleModel.findByRoleId(roleId);
-            let { resHeroes } = await defaultHeroes(role);
+            let { resHeroes } = await defaultHeroes(role,  challengeCnt, challengeRefTime, true);
             return resResult(STATUS.SUCCESS,  { heroes: resHeroes, challengeCnt, challengeRefTime, isDefaultHero} );
         } else {
             for (let dataId = PVP_HERO_POS.START; dataId <= PVP_HERO_POS.END; dataId++) {

game-server/app/servers/connector/remote/connectorRemote.ts

@@ -1,4 +1,4 @@
-import { Application, ChannelService, FrontendSession, RemoterClass } from 'pinus';
+import { Application, ChannelService, FrontendSession, pinus, RemoterClass } from 'pinus';
 import { STATUS } from '../../../consts/statusCode';
 import { resResult } from '../../../pubUtils/util';
 import { getRedis, setRedis, delRedis } from '../../../services/redisService';
@@ -28,7 +28,8 @@ export class ConnectorRemote {
         await sessionService.akick(uid);
     }
 
-    public async pushMessage(sid: string, uid: string, route: string, data:any) {
+    public async pushMessage( uid: string, route: string, data:any) {
+        let sid = pinus.app.getServerId();
         if (!!sid) {
             let uids = [{uid, sid}];
             this.channelService.pushMessageByUids(route, data, uids);

game-server/app/services/pvpService.ts

@@ -238,19 +238,24 @@ export function getLvByScore(heroScores: HeroScores[]) {
     return getPLvByScore(score);
 }
 
-export async function defaultHeroes ( role:RoleType, challengeCnt?:number, challengeRefTime?:number,) {
+export async function defaultHeroes ( role:RoleType, challengeCnt?:number, challengeRefTime?:number, isUpdate?: boolean) {
-    let { heroes } = await PvpDefenseModel.findByRoleId(role.roleId);
+    let { heroes, isDefaultHero } = await PvpDefenseModel.findByRoleId(role.roleId);
-    var orders = [1, 2, 3, 4, 5];
+    if (!isUpdate && !isDefaultHero) {
-    heroes.sort(function(a, b) {
+        return;
-        if (!!a.order&& !!a.hero) {
+    }
-            let index = orders.indexOf(a.order);
+    let orders = [1, 2, 3, 4, 5];
-            orders.splice(index, 1);
-        }
-        return b.ce - b.dataId - a.ce + a.dataId;
-    });
     role.topFive.sort(function(a, b) {
         return b.ce - a.ce;
     });
+    heroes.sort(function(a, b) {
+        return b.ce - b.dataId - a.ce + a.dataId;
+    });
+    for (let hero of heroes) {
+        if (!!hero.order&& !!hero.hero && _.findIndex(role.topFive, {hid: hero.actorId}) != -1) {
+            let index = orders.indexOf(hero.order);
+            orders.splice(index, 1);
+        }
+    }
     let defCe = 0;
     let num  = 0;
     for (let i = 0; i < role.topFive.length; i++) {

game-server/app/services/timeTaskService.ts

@@ -8,7 +8,7 @@ import PvpDefenseType,{ PvpDefenseModel } from '../db/PvpDefense';
 import { PVP } from '../pubUtils/dicParam';
 import { nowSeconds, getTodayZeroPoint } from '../pubUtils/timeUtil';
 import { getPvpGkWarIds, getPvpRankRewards, getPvpHeroRewards } from '../pubUtils/data';
-import { getRandomArr } from '../pubUtils/util';
+import { deepCopy, getRandomArr } from '../pubUtils/util';
 import { getLvByScore } from './pvpService';
 import { getMyRank, setRank, getRedis } from './redisService';
 import { REDIS_KEY } from '../consts';
@@ -49,21 +49,21 @@ export async function setPvpSeasonResult(obj:{ name:string }) {
     for (let page = 0; page < 3; page++) {
         let pvpDefenses = await PvpDefenseModel.getPvpDef(500, page);
         let addMails = new Array<MailType>();
+        let pushMessage = new Array<any>();
         for (let pvpDefense of pvpDefenses) {
             if (pvpDefense.seasonNum !== seasonNum) {
-                await setPvpDefResultOnTime(pvpDefense, seasonNum, seasonEndTime, addMails);
+                await setPvpDefResultOnTime(pvpDefense, seasonNum, seasonEndTime, addMails,pushMessage);
             }
         }
         await MailModel.addMails(addMails);
-        // let key = 'login_roleId_' + pvpDefense.roleId; 
+        for (let message of pushMessage) {      
-        // let sid = await getRedis(key);
+            pinus.app.rpc.connector.connectorRemote.pushMessage.toServer(message.sid, message.uid, message.route, message.data);
-        // if (!!sid) {
+        }
-        //     pinus.app.rpc.connector.connectorRemote.pushMessage.toServer(sid, pvpDefense.roleId, 'onMailsAdd', [mail]);
-        // }
     }
+    return { seasonNum, seasonEndTime };
 }
 
-export async function setPvpDefResultOnTime(pvpDefense: PvpDefenseType, seasonNum: number, seasonEndTime:number, addMails: Array<MailType>) {
+export async function setPvpDefResultOnTime(pvpDefense: PvpDefenseType, seasonNum: number, seasonEndTime:number, addMails: Array<MailType>, pushMessage:Array<any>) {
     let role = await RoleModel.findByRoleId(pvpDefense.roleId);
     if (!role) {
         return;
@@ -75,8 +75,13 @@ export async function setPvpDefResultOnTime(pvpDefense: PvpDefenseType, seasonNu
     setRank(REDIS_KEY.PVP_RANK, 0, pvpDefense.roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), params);
     //下发邮件
     const doc = new MailModel();
-    const mail = Object.assign(doc.toJSON(), { goods, sendName: '系统', mailId: 1, sendTime: nowSeconds()});
+    const mail = Object.assign(doc.toJSON(), {roleId: pvpDefense.roleId, goods, sendName: '系统', mailId: 1, sendTime: nowSeconds()});
     addMails.push(mail);
+    let key = 'login_roleId_' + pvpDefense.roleId; 
+    let sid = await getRedis(key);
+    if (!!sid) {
+        pushMessage.push({route: 'onMailsAdd', data:[mail], uid: pvpDefense.roleId, sid});
+    }
     return pvpDefense;
 }
 
@@ -127,14 +132,14 @@ export async function setPvpDefResult(pvpDefense: PvpDefenseType, seasonNum: num
 export async function resetPvpWarId() {
     console.log('resetPvpWarId');
     let systemConfig = await SystemConfigModel.findSystemConfig();
-    let warIds = getPvpGkWarIds();
+    let warIds = deepCopy(getPvpGkWarIds());
     let index = _.indexOf(warIds, systemConfig.warId);
     if (index != -1) {
         warIds.splice(index, 1);
     }
     let res = getRandomArr(warIds, 1);
     let warId = res[0];//TODO随机地图
-    await SystemConfigModel.updateSystemConfig({ warId });
+    return await SystemConfigModel.updateSystemConfig({ warId });
 }
 
 async function setNextPvpTime() {

shared/db/Mail.ts

@@ -7,10 +7,7 @@ import { nowSeconds } from '../pubUtils/timeUtil';
 
 export default class Mail extends BaseModel {
     @prop({ required: true })
-    roleId: number;
+    roleId: string;
-    
-    @prop({ required: true })
-    seqId: number;
 
     @prop({ required: true })
     mailId: number;
@@ -25,8 +22,7 @@ export default class Mail extends BaseModel {
     sendName: string; 
 
     public static async addMails( mails: Array<MailType>) {
-       let mailInfos:Array<MailType>  = await MailModel.insertMany(mails);
+        await MailModel.insertMany(mails);
-       return mailInfos;
     }
 
     public static async addMail(params:{ goods: Array<RewardInter>, sendName: string, mailId: number, sendTime?: number}) {