pvp测试接口

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

@@ -10,7 +10,7 @@ import { SystemConfigModel } from '../../../db/SystemConfig'
 import { PvpDefenseModel, OppPlayers } from '../../../db/PvpDefense';
 import { oppHeroesDefenseInter, pvpEndParamInter, RankParam, PlayerDetail, PlayerDetailHero } from '../../../pubUtils/interface';
 import { PVP_HERO_POS, REDIS_KEY } from '../../../consts';
-
+import { PVP } from '../../../pubUtils/dicParam';
 import { addItems } from '../../../services/rewardService';
 import { HeroModel } from '../../../db/Hero';
 import { checkBattleHeroesByHid } from '../../../services/normalBattleService';
@@ -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';
+import { setPvpSeasonResult, resetPvpWarId, resetPvpSeasonTime } from '../../../services/timeTaskService';
 export default function(app: Application) {
     return new PvpHandler(app);
 }
@@ -28,27 +28,35 @@ export class PvpHandler {
     constructor(private app: Application) {
     }
 
-    async addRoleScore(msg: {score:number}, session: BackendSession) {
+    async addRoleScore(msg: {heroScores: Array<{hid: number, score:number}>}, session: BackendSession) {
-        let { score } = msg;
+        let { heroScores: addHeroScores } = msg;
         let roleId = session.get('roleId');
-        let pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
+        let {heroScores, hisScore, score} = await PvpDefenseModel.findByRoleId(roleId);
-        score += pvpDefense.score;
+        for (let {hid, score: heroScore} of addHeroScores) {
+            if (heroScore < 0) continue;
+            let index = findIndex(heroScores, {hid});
+            if (index!= -1) {
+                let oldScore = heroScores[index].score;
+                heroScores[index].score = heroScore;
+                score = score - oldScore + heroScore;
+            } else {
+                heroScores.push({hid, score :heroScore});
+            }
+        }
         if (score < 0) {
             score = 0;
         }
-        let hisScore = pvpDefense.score;
         if (hisScore < score) {
             hisScore = score;
         }
-        pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { score, hisScore });
+        let pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { score, hisScore , heroScores});
         let roleName = session.get('roleName');
         const role = await RoleModel.findByRoleId(roleId);
 
         // 加入排行榜
         let params = new RankParam(roleName, role.lv, role.vLv, role.headHid, role.sHid, role.title);
         await setRank(REDIS_KEY.PVP_RANK, 0, roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), params);
-        return resResult(STATUS.SUCCESS, {score, hisScore});
+        return resResult(STATUS.SUCCESS, {score, hisScore, heroScores});
-
     }
 
     async debugPvpSeasonReset(msg: {}, session: BackendSession) {
@@ -61,6 +69,22 @@ export class PvpHandler {
         return resResult(STATUS.SUCCESS, {systemConfig});
     }
 
+    async debugPvpSeasonResetTime(msg: {day: number}, session: BackendSession) {
+        let { day } = msg;
+        let { seasonNum, seasonEndTime } = await resetPvpSeasonTime(day);
+        return resResult(STATUS.SUCCESS, { seasonNum, seasonEndTime });
+    }
+
+    async debugAddChallengeCnt(msg: {challengeCnt: number}, session: BackendSession) {
+        let { challengeCnt } = msg; 
+        let roleId = session.get('roleId');
+        if (challengeCnt > PVP.PVP_CHALLENGE_COUNTS) {
+            challengeCnt = PVP.PVP_CHALLENGE_COUNTS;
+        }
+        let { challengeRefTime } = await PvpDefenseModel.updateInfoAndInclude(roleId, { challengeCnt, challengeRefTime: nowSeconds()});
+        return resResult(STATUS.SUCCESS, { challengeCnt, challengeRefTime });
+    }
+
     async getData (msg: {}, session: BackendSession) {
         let roleId = session.get('roleId');
         let { pvpDefense, warId } = await findPvpDefAllByRoleId(roleId);
@@ -86,7 +110,7 @@ export class PvpHandler {
         let pvpDefense = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
  
         // 刷新次数及消耗
-        let {refOppCnt, refOppTime, consume} = getRefOppCnt(pvpDefense.refOppCnt, pvpDefense.refOppTime);
+        let { refOppCnt, refOppTime, consume } = getRefOppCnt(pvpDefense.refOppCnt, pvpDefense.refOppTime);
         if(refOppCnt >= gameData.maxPvpRefreshCnt) {
             return resResult(STATUS.PVP_REFRESH_CNT_REACH_MAX);
         }

game-server/app/services/pvpService.ts

@@ -17,7 +17,6 @@ import { HeroesRecord } from '../db/PvpRecord';
 import { HeroModel, HeroType } from '../db/Hero';
 import { CeAttrNumber, CeAttr, CeAttrRole } from '../db/generalField';
 import { DicWarJson } from '../pubUtils/dictionary/DicWarJson';
-import { OutliningSpanKind } from 'typescript';
 import { findWhere, findIndex } from 'underscore';
 
 

game-server/app/services/timeTaskService.ts

@@ -2,7 +2,7 @@
  * 体力系统
  */
 
-import { scheduleJob } from 'node-schedule';
+import { scheduleJob,  } from 'node-schedule';
 import { SystemConfigModel } from '../db/SystemConfig';
 import PvpDefenseType,{ PvpDefenseModel } from '../db/PvpDefense';
 import { PVP } from '../pubUtils/dicParam';
@@ -21,6 +21,8 @@ const PER_SECOND = 1 * 1000;
 const PER_DAY = 24 * 60 * 60;
 const SETTLE_DIFF = 29 * 60;
 const LIMIT_NUM = 1000;
+let seasonJobId;
+let warJobId;
 export async function init() {
     let seasonEndTime = 0;
     let systemConfig = await SystemConfigModel.findSystemConfig();
@@ -39,8 +41,9 @@ export async function init() {
         }
     }
     let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
-    scheduleJob(settleTime, setPvpSeasonResult)
+    seasonJobId = scheduleJob(settleTime, setPvpSeasonResult);
-    scheduleJob("0 0 0 * * 1", resetPvpWarId)
+    warJobId = scheduleJob("0 0 0 * * 1", resetPvpWarId);
+    console.log ('seasonJobId = = = = = = = = =' + seasonJobId);
 }
 
 export async function setPvpSeasonResult(obj:{ name:string }) {
@@ -146,7 +149,7 @@ async function setNextPvpTime() {
     let seasonEndTime = PVP.PVP_SEASON_DAYS * PER_DAY + getTodayZeroPoint();
     let systemConfig = await SystemConfigModel.updateSeason(seasonEndTime);
     let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
-    scheduleJob(settleTime, setPvpSeasonResult);
+    seasonJobId = scheduleJob(settleTime, setPvpSeasonResult);
     return systemConfig;
 }
 
@@ -156,4 +159,24 @@ function getScore(arr, score) {
             return item;
         }
     }
-}
+}
+
+export async function resetPvpSeasonTime(day: number) {
+    seasonJobId.cancel();   
+    let seasonEndTime = 0;
+    let seasonNum = 1;
+    let systemConfig = await SystemConfigModel.findSystemConfig();
+    if (!systemConfig) {
+        let warIds = getPvpGkWarIds();
+        let warId = warIds[0];//TODO随机地图
+        seasonEndTime = day * PER_DAY + getTodayZeroPoint();
+        systemConfig = await SystemConfigModel.createSystemConfig( seasonEndTime, warId );
+    } else {    
+        seasonEndTime = day * PER_DAY + getTodayZeroPoint();
+        seasonNum = systemConfig.seasonNum + 1;
+        await SystemConfigModel.updateSystemConfig({ seasonEndTime, seasonNum: seasonNum});
+    }
+    let settleTime = (seasonEndTime - SETTLE_DIFF)* PER_SECOND;
+    seasonJobId = scheduleJob(settleTime, setPvpSeasonResult)
+    return { seasonEndTime, seasonNum };
+}