pvp：修复赛季相关

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

@@ -46,7 +46,8 @@ export class PvpHandler {
         }
         // 如果没有发过，将上赛季的奖励发下
         pvpDefense = await sendLastSeasonRewardIfNotSent(pvpDefense);
-        let { seasonNum, seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
+        let seasonNum: number = this.app.get('pvpSeasonNum');
+        let seasonEndTime: number = this.app.get('pvpSeasonEndTime');
 
         let update: pvpUpdateInter = { };
         let result = new PvpDataReturn(); // 返回对象
@@ -60,7 +61,7 @@ export class PvpHandler {
         if(refOppObj.shouldRefOpp) {
             if(pvpDefense.attack) {
                 let role = <RoleType>pvpDefense.role;
-                let oppPlayers = await refreshEnemies(role, seasonNum, pvpDefense.attack.score, pvpDefense.attack.pLv||1);
+                let oppPlayers = await refreshEnemies(role, seasonNum, pvpDefense.score, pvpDefense.attack.score, pvpDefense.attack.pLv||1);
                 update.oppPlayers = oppPlayers;
             }
             update = { ...update, ...refOppObj }
@@ -81,13 +82,13 @@ export class PvpHandler {
         let oppPlayersReturn = await getEnemies(pvpDefense.oppPlayers||[], pvpDefense.winStreakNum);
         result.setOppPlayers(oppPlayersReturn);
         // 赛季结算
-        let pvpSeasonResult = await PvpSeasonResultModel.getPvpSeasonResult(roleId, pvpDefense.seasonNum);
+        let pvpSeasonResult = await PvpSeasonResultModel.getPvpSeasonResult(roleId);
         if (!!pvpSeasonResult && !!pvpSeasonResult.show) {
             result.setPvpSeasonResult(pvpSeasonResult);
             await PvpSeasonResultModel.updatePvpSeasonResult(roleId, pvpSeasonResult.seasonNum, { show: false });
         }
         // 拍卖
-        let r = new Rank(REDIS_KEY.PVP_RANK, {});
+        let r = new Rank(REDIS_KEY.PVP_RANK, { seasonNum });
         let myRank = await r.getMyRank({ roleId });//去redis中获取排名
         result.setMyRank(myRank);
 
@@ -115,8 +116,8 @@ export class PvpHandler {
 
         // 刷新对手
         let role = <RoleType>pvpDefense.role;
-        let { seasonNum } = await PVPConfigModel.findCurPVPConfig();
+        let seasonNum: number = this.app.get('pvpSeasonNum');
-        let oppPlayers = await refreshEnemies(role, seasonNum, pvpDefense.attack.score, pvpDefense.attack.pLv||1);
+        let oppPlayers = await refreshEnemies(role, seasonNum, pvpDefense.score, pvpDefense.attack.score, pvpDefense.attack.pLv||1);
 
         pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { oppPlayers, ...refOppObj });
 
@@ -125,7 +126,7 @@ export class PvpHandler {
         let oppPlayersReturn = await getEnemies(pvpDefense.oppPlayers, pvpDefense.winStreakNum);
         result.setOppPlayers(oppPlayersReturn);
 
-        return resResult(STATUS.SUCCESS, pick(result, ['oppPlayers', 'refOppCnt', 'setAttackCnt']));
+        return resResult(STATUS.SUCCESS, pick(result, ['oppPlayers', 'refOppCnt', 'buyAttackCnt', 'setAttackCnt']));
     }
     
     // 获取对手阵容具体信息
@@ -134,6 +135,7 @@ export class PvpHandler {
 
         let oppoRoleId = msg.roleId;
         let pvpDefense = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
+        if(!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
         let { oppPlayers } = pvpDefense;
 
         let curOpp = oppPlayers.find(cur => cur.roleId == oppoRoleId);
@@ -159,7 +161,7 @@ export class PvpHandler {
         let pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
         if (!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
         // 检查挑战次数
-        let { seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
+        let seasonEndTime: number = this.app.get('pvpSeasonEndTime');
         let { challengeCnt, challengeRefTime } = refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
         if (challengeCnt == 0) {
             return resResult(STATUS.PVP_CHALLENGE_TIMES_NOT_ENOUGH);
@@ -234,8 +236,9 @@ export class PvpHandler {
         await PvpHistoryOppModel.setStatus(roleId, oppRoleId, 1);
 
         // 刷新对手
-        let { seasonNum, seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
+        let seasonNum: number = this.app.get('pvpSeasonNum');
-        let oppPlayers = await refreshEnemies(role, seasonNum, pvpDefense.attack.score, pvpDefense.attack.pLv||1);
+        let seasonEndTime: number = this.app.get('pvpSeasonEndTime');
+        let oppPlayers = await refreshEnemies(role, seasonNum, pvpDefense.score ,pvpDefense.attack.score, pvpDefense.attack.pLv||1);
         update.oppPlayers = oppPlayers;
 
         // 更新battleRecord
@@ -257,7 +260,7 @@ export class PvpHandler {
         result.setOppPlayers(oppPlayersReturn);
 
         // 加入排行榜
-        let r = new Rank(REDIS_KEY.PVP_RANK, {});
+        let r = new Rank(REDIS_KEY.PVP_RANK, { seasonNum });
         await r.setRankWithRoleInfo(roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), role);
         let myRank = await r.getMyRank({ roleId });
         result.setMyRank(myRank);
@@ -303,8 +306,8 @@ export class PvpHandler {
         if(refOppObj.shouldRefOpp) {
             if(pvpDefense.attack) {
                 let role = await RoleModel.findByRoleId(roleId);
-                let { seasonNum } = await PVPConfigModel.findCurPVPConfig();
+                let seasonNum: number = this.app.get('pvpSeasonNum');
-                let oppPlayers = await refreshEnemies(role, seasonNum, pvpDefense.attack.score, pvpDefense.attack.pLv||1);
+                let oppPlayers = await refreshEnemies(role, seasonNum, pvpDefense.score, pvpDefense.attack.score, pvpDefense.attack.pLv||1);
                 update.oppPlayers = oppPlayers;
             }
         }
@@ -341,7 +344,9 @@ export class PvpHandler {
             return resResult(STATUS.PVP_SET_ATTACK_CNT_NOT_ENOUGH);
         }
         refOppObj.setAttackCnt ++;
-        let { seasonNum, seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
+        
+        let seasonNum: number = this.app.get('pvpSeasonNum');
+        let seasonEndTime: number = this.app.get('pvpSeasonEndTime');
         let refChallengeObj = refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
         // 更新挑战阵容
         let score = 0;
@@ -355,7 +360,7 @@ export class PvpHandler {
         let lineupCe = await generPvpLineupCe(roleId, pvpDefense.lineupCe, attack.heroes, []);
         // 刷对手
         let role = <RoleType>pvpDefense.role;
-        let oppPlayers = await refreshEnemies(role, seasonNum, attack?.score||0, attack?.pLv||1);
+        let oppPlayers = await refreshEnemies(role, seasonNum, pvpDefense.score, attack?.score||0, attack?.pLv||1);
         // 保存
         pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { ...refOppObj, ...refChallengeObj, attack, oppPlayers, lineupCe });
         // 返回
@@ -364,7 +369,7 @@ export class PvpHandler {
         let oppPlayersReturn = await getEnemies(pvpDefense.oppPlayers||[], pvpDefense.winStreakNum);
         result.setOppPlayers(oppPlayersReturn);
 
-        return resResult(STATUS.SUCCESS, pick(result, ['attack', 'oppPlayers', 'setAttackCnt', 'challengeCnt', 'challengeRefTime']));
+        return resResult(STATUS.SUCCESS, pick(result, ['attack', 'oppPlayers', 'buyAttackCnt', 'setAttackCnt', 'challengeCnt', 'challengeRefTime']));
     }
 
     //3. 保存防守阵容
@@ -378,7 +383,7 @@ export class PvpHandler {
         let pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
         if(!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
         // 刷新次数
-        let { seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
+        let seasonEndTime: number = this.app.get('pvpSeasonEndTime');
         let refChallengeObj = refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
         // 更新防守阵容
         let score = 0, heroIdMap = new Map<number, string>(), hids: number[] = [];
@@ -424,7 +429,8 @@ export class PvpHandler {
 
         let roleId = session.get('roleId');
 
-        let r = new Rank(REDIS_KEY.PVP_RANK, {});
+        let seasonNum: number = this.app.get('pvpSeasonNum');
+        let r = new Rank(REDIS_KEY.PVP_RANK, { seasonNum });
         let { ranks, myRank } = await r.getRankListWithMyRank({ roleId });
 
         if (!myRank) {
@@ -456,11 +462,13 @@ export class PvpHandler {
             for (let hero of pvpHistoryOpp.heroes) {
                 let newHero = new PlayerDetailHero();
                 newHero.setPvpHeroInfo(hero);
+                newHero.setIsDefense(true);
                 heroes.push(newHero);
             }
             for (let hero of pvpHistoryOpp.otherHeroes) {
                 let newHero = new PlayerDetailHero();
                 newHero.setPvpHeroInfo(hero);
+                newHero.setIsDefense(false);
                 heroes.push(newHero);
             }
             result = new PlayerDetail({ ...pvpHistoryOpp, roleId: pvpHistoryOpp.oppRoleId, heroes, rank: pvpHistoryOpp.rankLv });
@@ -470,15 +478,15 @@ export class PvpHandler {
             let role = await RoleModel.findByRoleId(oppoRoleId);
 
             let heroes = new Array<PlayerDetailHero>();
-            for (let { hid, lv, star, colorStar, quality, skinId } of dbHeroes) {
+            for (let dbHero of dbHeroes) {
-                let heroScore = pvpDefense.heroScores.find(cur => cur.hid == hid);
+                let hero = new PlayerDetailHero();
-                heroes.push({
+                hero.setByDbHero(dbHero);
-                    actorId: hid, lv, star, colorStar, quality, skinId,
+                hero.setPvpDefense(pvpDefense);
-                    score: heroScore ? heroScore.score : 0
+                heroes.push(hero);
-                });
             }
             heroes.sort((a, b) => b.score - a.score);
-            let r = new Rank(REDIS_KEY.PVP_RANK, {});
+            let seasonNum: number = this.app.get('pvpSeasonNum');
+            let r = new Rank(REDIS_KEY.PVP_RANK, { seasonNum });
             let rank = await r.getMyRank({ roleId: oppoRoleId });//去redis中获取排名
 
             result = new PlayerDetail({ ...role, ...pvpDefense, heroes, rank });
@@ -494,7 +502,7 @@ export class PvpHandler {
         let sid: string = session.get('sid');
         let roleName = session.get('roleName');
         
-        let { seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
+        let seasonEndTime: number = this.app.get('pvpSeasonEndTime');
         let { hisScore, receivedBox, challengeCnt: lastChallengeCnt, challengeRefTime: lastChallengeRefTime } = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
         let pvpBoxs = getPvpBoxs();
         let pvpBox = findWhere(pvpBoxs, { id });
@@ -552,7 +560,8 @@ export class PvpHandler {
         const role = await RoleModel.findByRoleId(roleId);
 
         // 加入排行榜
-        let r = new Rank(REDIS_KEY.PVP_RANK, {});
+        let seasonNum: number = this.app.get('pvpSeasonNum');
+        let r = new Rank(REDIS_KEY.PVP_RANK, { seasonNum });
         await r.setRankWithRoleInfo(roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), role);
 
         // 任务
@@ -560,17 +569,6 @@ export class PvpHandler {
 
         return resResult(STATUS.SUCCESS, { score, hisScore, heroScores });
     }
-/*
-    async debugPvpSeasonReset(msg: {}, session: BackendSession) {
-        await pvpSeasonEnd({ name: 'exce setPvpSeasonResult debug' });
-        let systemConfig = await createNextPvpSeason();
-        return resResult(STATUS.SUCCESS, { seasonNum: systemConfig.seasonNum, seasonEndTime: systemConfig.seasonEndTime })
-    }
-
-    async debugPvpWarReset(msg: {}, session: BackendSession) {
-        let systemConfig = await resetPvpWarId();
-        return resResult(STATUS.SUCCESS, { systemConfig });
-    }
 
     async debugPvpSeasonResetTime(msg: { day: number }, session: BackendSession) {
         let { day: hour } = msg;
@@ -578,7 +576,6 @@ export class PvpHandler {
         return resResult(STATUS.SUCCESS, { seasonNum, seasonEndTime });
     }
 
-    */
     async debugAddChallengeCnt(msg: { challengeCnt: number }, session: BackendSession) {
         let { challengeCnt } = msg;
         let roleId = session.get('roleId');

game-server/app/servers/battle/remote/battleRemote.ts

@@ -1,4 +1,5 @@
 import { Application, ChannelService, FrontendSession, RemoterClass, HandlerService, } from 'pinus';
+import { PVPConfigType } from '../../../db/SystemConfig';
 import { reloadResources } from '../../../pubUtils/data';
 
 export default function (app: Application) {
@@ -78,4 +79,12 @@ export class BattleRemote {
     public async reloadResources() {
         reloadResources();
     }
+
+
+    public setPvpSeasonNum(pvpConfig: PVPConfigType) {
+        if(pvpConfig) {
+            this.app.set('pvpSeasonNum', pvpConfig.seasonNum);
+            this.app.set('pvpSeasonEndTime', pvpConfig.seasonEndTime);
+        }
+    }
 }

game-server/app/servers/role/handler/friendHandler.ts

@@ -668,27 +668,22 @@ export class FriendHandler {
             for (let hid of showLineup) {
                 let curHero = dbHeroes.find(cur => cur.hid == hid);
                 if (curHero) {
-                    let { lv, star, colorStar, quality, skinId } = curHero;
+                    let hero = new PlayerDetailHero();
-                    heroes.push({
+                    hero.setByDbHero(curHero);
-                        actorId: hid, skinId, lv, star, colorStar, quality,
-                        score: 0
-                    });
                 }
             }
         } else {
             for (let { hid } of topLineup) {
                 let curHero = dbHeroes.find(cur => cur.hid == hid);
                 if (curHero) {
-                    let { lv, star, colorStar, quality, skinId } = curHero;
+                    let hero = new PlayerDetailHero();
-                    heroes.push({
+                    hero.setByDbHero(curHero);
-                        actorId: hid, lv, skinId, star, colorStar, quality,
-                        score: 0
-                    });
                 }
             }
         }
 
-        let r = new Rank(REDIS_KEY.PVP_RANK, {});
+        let seasonNum: number = this.app.get('pvpSeasonNum');
+        let r = new Rank(REDIS_KEY.PVP_RANK, { seasonNum });
         let rank = await r.getMyRank({ roleId: oppoRoleId });//去redis中获取排名
 
         result = new PlayerDetail({ ...role, defCe: topLineupCe, heroes });

game-server/app/servers/role/remote/roleRemote.ts

@@ -9,6 +9,7 @@ import { getInitRoleInfo } from '../../../pubUtils/roleUtil';
 import { DEFAULT_HEROES } from '../../../consts';
 import { Figure } from '../../../domain/dbGeneral';
 import { getDefaultRoleInfo } from '../../../services/roleService';
+import { PVPConfigType } from '../../../db/SystemConfig';
 export default function (app: Application) {
     new HandlerService(app, {});
     return new RoleRemote(app);
@@ -107,4 +108,12 @@ export class RoleRemote {
     public async reloadResources() {
         reloadResources();
     }
+
+
+    public setPvpSeasonNum(pvpConfig: PVPConfigType) {
+        if(pvpConfig) {
+            this.app.set('pvpSeasonNum', pvpConfig.seasonNum);
+            this.app.set('pvpSeasonEndTime', pvpConfig.seasonEndTime);
+        }
+    }
 }

game-server/app/services/pvpService.ts

@@ -21,9 +21,10 @@ import { PvpHistoryOppModel, PvpHistoryOppType } from '../db/PvpHistoryOpp';
 import { Rank } from './rankService';
 import { CounterModel } from '../db/Counter';
 import { DicRankRewads } from '../pubUtils/dictionary/DicPvpRankReward';
-import { PvpSeasonResultModel } from '../db/PvpSeasonResult';
+import { PvpSeasonResultModel, PvpSeasonResultType } from '../db/PvpSeasonResult';
 import { checkTask } from '../services/taskService';
 import { sendMailByContent } from './mailService';
+import { RoleRankInfo } from '../domain/rank';
 
 /**
  * 返回对手三人信息
@@ -57,13 +58,13 @@ export async function getEnemies(oppPlayers: OppPlayer[], winStreakNum: number)
  * @param score 我的军功
  * @param pLv 我的排名
  */
-export async function refreshEnemies(role: RoleType, seasonNum: number, score: number, pLv: number) {
+export async function refreshEnemies(role: RoleType, seasonNum: number, sumScore: number, score: number, pLv: number) {
     let { roleId } = role;
     let oppPlayers: OppPlayer[] = [];
     let opp = dicPvpOpponent.values()
     for (let dicOpp of opp) {
         let flag = false; // 是否筛选成功
-        if (score >= PVP_CONST.SCORE_LINE) { // 将这个放到const
+        if (sumScore >= PVP_CONST.SCORE_LINE) { // 将这个放到const
             flag = await matchPlayer(seasonNum, oppPlayers, roleId, pLv, dicOpp); // 按照等级匹配对手
             if (!flag) flag = await matchPlayerByRank(seasonNum, oppPlayers, roleId, dicOpp.id); // 当前后分数段没有时，返回前一名的玩家
             if (!flag) flag = await matchRobot(oppPlayers, role, score, dicOpp);
@@ -78,7 +79,7 @@ export async function refreshEnemies(role: RoleType, seasonNum: number, score: n
 
 export async function matchPlayerByRank(seasonNum: number, oppPlayers: OppPlayer[], roleId: string, pos: number) {
     // console.log('matchPlayerByRank', JSON.stringify(oppPlayers))
-    let r = new Rank(REDIS_KEY.PVP_RANK, {});
+    let r = new Rank(REDIS_KEY.PVP_RANK, { seasonNum });
     let ridRanks = new Array<number>(); // 已经被使用了的排名
     for (let { roleId: curRoleId } of oppPlayers) {
         let rankLv = await r.getMyRank({ roleId: robotIdComBack(curRoleId) });
@@ -183,7 +184,9 @@ async function generPlayerOppHis(pvpdefense: PvpDefenseType, roleId: string, pos
     if(!defense) return false;
     let { warId, heroes: defenseHeroes } = defense;
     let role = <RoleType>pvpdefense.role;
-    let r = new Rank(REDIS_KEY.PVP_RANK, {});
+
+    let seasonNum: number = pinus.app.get('pvpSeasonNum');
+    let r = new Rank(REDIS_KEY.PVP_RANK, { seasonNum });
     let rankLv = await r.getMyRank({ roleId: role.roleId });
     let dbHeroes = await HeroModel.findByRole(role.roleId, [{ field: 'ce', sortBy: -1 }]);
     let heroes = new Array<PvpEnemies>();
@@ -202,6 +205,7 @@ async function generPlayerOppHis(pvpdefense: PvpDefenseType, roleId: string, pos
                 let { attribute, ce } = getPlayerAttribute(dbHero.lv, dbHero.attr, role.attr);
                 heroInfo.setAttribute(attribute);
                 let enemy = new PvpEnemies(warJson, heroInfo, hs ? hs.score : 0, ce);
+                enemy.setOutIndex(h.order);
                 heroes.push(enemy);
                 defCe += ce;
             }
@@ -244,6 +248,7 @@ async function matchRobot(oppPlayers: OppPlayer[], role: RoleType, score: number
         defCe += ce;
         heroInfo.setAttribute(attribute);
         let enemy = new PvpEnemies(h, heroInfo, 0, ce);
+        enemy.setOutIndex(h.outIndex);
         heroes.push(enemy);
     }
 
@@ -322,8 +327,8 @@ export function comsumeChallengeCnt(challengeCnt: number, challengeRefTime: numb
 }
 
 export async function sendLastSeasonRewardIfNotSent(pvpDefense: PvpDefenseType) {
-    let pvpConfig = await PVPConfigModel.findCurPVPConfig(); // 当前的pvp赛季
+    let seasonNum: number = pinus.app.get('pvpSeasonNum');
-    if(pvpDefense.seasonNum != pvpConfig.seasonNum && pvpConfig.seasonEndTime < nowSeconds()) {
+    if(pvpDefense.seasonNum != seasonNum) {
         let oldPvpCongig = await PVPConfigModel.findPVPConfig(pvpDefense.seasonNum);
         pvpDefense = await sendPVPRewardToUser(pvpDefense, pvpDefense.seasonNum, oldPvpCongig.seasonEndTime);
     }
@@ -510,19 +515,15 @@ export async function generPVPOppRecInfo(isSuccess: boolean, curOpp: OppPlayer,
  * @param obj 
  */
  export async function pvpSeasonEnd(pvpConfig: PVPConfigType) {
-    const pageNum = 500;
+    console.log('exce pvpSeasonEnd' + pvpConfig.seasonNum);
-    console.log('exce pvpSeasonEnd' + pvpConfig?.seasonNum);
-    let systemConfig = await PVPConfigModel.findCurPVPConfig();
     let resultMaxRank = gameData.pvpRankMax.max;//根据排行榜的奖励表，获得最大排名挡位的最小值，其余不在结算中结算的玩家按照最大排名挡位在登录或进入pvp时结算
-    let maxPage = (resultMaxRank.min + 1000) / pageNum; //保底结算玩家数量
+    let r = new Rank(REDIS_KEY.PVP_RANK, { seasonNum: pvpConfig.seasonNum });
-    let lastPageNum = resultMaxRank.min % pageNum;
+    let allRank = <RoleRankInfo[]>(await r.getRankByRank(0, resultMaxRank.min - 2));
-    for (let page = 0; page < maxPage + 1; page++) {
+    console.log('******** resultMaxRank', resultMaxRank.max)
-        let pvpDefenses = await PvpDefenseModel.getPvpDef(pageNum, page == maxPage ? lastPageNum : page);
+    for(let { rank, roleId } of allRank) {
-        for (let pvpDefense of pvpDefenses) {
+        console.log('******** pvpSeasonEnd: ', rank, roleId);
-            if (pvpDefense.seasonNum !== systemConfig.seasonNum) {
+        let pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
-                await sendPVPRewardToUser(pvpDefense, systemConfig.seasonNum, systemConfig.seasonEndTime);
+        await sendPVPRewardToUser(pvpDefense, pvpConfig.seasonNum, pvpConfig.seasonEndTime);
-            }
-        }
     }
     await PVPConfigModel.setReward(pvpConfig.seasonNum);
 }
@@ -549,7 +550,20 @@ export async function sendPVPRewardToUser(pvpDefense: PvpDefenseType, seasonNum:
             goods: heroGoods, endTime: seasonEndTime, notPush
         });
 
-    pvpDefense = await PvpDefenseModel.resetScores(pvpDefense.roleId, seasonNum + 1, pvpSeasonResult.newScore, pvpSeasonResult.newHeroScores);
+    return await resetPvpScores(pvpDefense, seasonNum + 1, pvpSeasonResult);
+}
+
+async function resetPvpScores(pvpDefense: PvpDefenseType, seasonNum: number, pvpSeasonResult: PvpSeasonResultType) {
+    let { roleId, attack, defense } = pvpDefense;
+    let { heroScores, score } = pvpSeasonResult;
+
+    let newAttack = <Attack>calLineupScore(attack, heroScores);
+    let newDefense = <Defense>calLineupScore(defense, heroScores);
+
+    pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { 
+        heroScores, score, attack: newAttack, defense: newDefense,
+        seasonNum, challengeCnt: PVP.PVP_CHALLENGE_COUNTS, challengeRefTime: 0, winStreakNum: 0 
+    });
     return pvpDefense;
 }
 
@@ -562,7 +576,7 @@ export async function sendPVPRewardToUser(pvpDefense: PvpDefenseType, seasonNum:
  */
 export async function savePvpSeasonResult(pvpDefense: PvpDefenseType, seasonNum: number, seasonEndTime: number, rankLv?: number) {
     if (!rankLv) {
-        let r = new Rank(REDIS_KEY.PVP_RANK, {});
+        let r = new Rank(REDIS_KEY.PVP_RANK, { seasonNum });
         rankLv = await r.getMyRank({ roleId: pvpDefense.roleId });// 获得排行榜排名
     }
     let pvpRankReward: DicRankRewads = getPvpRankRewardsByRank(rankLv);
@@ -589,6 +603,10 @@ export async function savePvpSeasonResult(pvpDefense: PvpDefenseType, seasonNum:
     let pvpSeasonResult = await PvpSeasonResultModel.updatePvpSeasonResult(pvpDefense.roleId, seasonNum, {
         ...pvpDefense, rankLv, heroGoods, rankGoods, show: true, newScore, newHeroScores, seasonEndTime
     });//结算修改玩家pvp信息
+    if(newScore > 0) {
+        let r = new Rank(REDIS_KEY.PVP_RANK, { seasonNum: seasonNum + 1 });
+        await r.setRankWithRoleInfo(pvpDefense.roleId, newScore, Date.now());
+    }
 
     // 更新任务
     await checkTask(pvpDefense.roleId, null, TASK_TYPE.PVP_HERO_SCORE, 0, false, { heroScores: pvpDefense.heroScores });

game-server/app/services/rankService.ts

@@ -930,10 +930,10 @@ export async function setRankRedisFromDb(type: string, args?: { serverId?: numbe
             await r.setRankWithGuildInfoArrParam(guild.code, [guild.lv, guild.activeWeekly, guild.activeUpdateTime], guild);
         }
     } else if (type == REDIS_KEY.PVP_RANK) {
-        let pvpConfig = await PVPConfigModel.findCurPVPConfig();
+        let seasonNum: number = pinus.app.get('pvpSeasonNum');
-        if(pvpConfig) {
+        if(seasonNum > 0) {
-            let ranks = await PvpDefenseModel.getRank(pvpConfig.seasonNum);//获得全服前1000名的排名，加入到redis中
+            let ranks = await PvpDefenseModel.getRank(seasonNum);//获得全服前1000名的排名，加入到redis中
-            let r = new Rank(type, {});
+            let r = new Rank(type, { seasonNum });
             r.setIsInit(true);
             for (let { roleId, role: _role, score, updatedAt } of ranks) {
                 let role = <RoleType>_role;

game-server/app/services/timeTaskService.ts

@@ -26,6 +26,7 @@ import { reportOneOnline } from './authenticateService';
 
 const PER_SECOND = 1 * 1000;
 const PER_DAY = 24 * 60 * 60;
+const PER_HOUR = 1 * 60 * 60;
 const SETTLE_DIFF_SECONDS = 29 * 60;
 const PER_MINUTE = 1 * 60;
 var seasonMakeRewardTimJobId: Job;
@@ -80,9 +81,15 @@ function getSeasonContinueDay(seasonNum: number) {
     return maxDay;
 }
 
-async function setPvpSeason() {
+async function setPvpSeasonJob() {
-    let pvpConfig = await PVPConfigModel.findCurPVPConfig();
+    await setPvpSeason();
-    if(!pvpConfig || pvpConfig.seasonEndTime <= nowSeconds() ) {
+}
+
+async function setPvpSeason(isForce?: boolean, hour?: number) {
+    let during = hour? hour * PER_HOUR: null;
+    let oldPvpConfig = await PVPConfigModel.findCurPVPConfig();
+    let pvpConfig = oldPvpConfig;
+    if(!pvpConfig || pvpConfig.seasonEndTime <= nowSeconds() || isForce) {
         if(pvpConfig && !pvpConfig.hasSettleReward) {
             await pvpSeasonEnd(pvpConfig);
         }
@@ -91,7 +98,7 @@ async function setPvpSeason() {
         let lastSeasonEndTime = pvpConfig? pvpConfig.seasonEndTime: 0;
 
         let newSeasonStartTime = lastSeasonEndTime;
-        let during = getSeasonContinueDay(lastSeasonNum + 1) * PER_DAY;
+        if(!during) during = getSeasonContinueDay(lastSeasonNum + 1) * PER_DAY;
         let rewardTime = SETTLE_DIFF_SECONDS;
         if(nowSeconds() - lastSeasonEndTime > during) {
             newSeasonStartTime = <number>getTimeFun().getDayZeroPoint(0);
@@ -99,8 +106,19 @@ async function setPvpSeason() {
         let newSeasonNum = await CounterModel.getNewCounter(COUNTER.PVP_SEASON_NUM);
         pvpConfig = await PVPConfigModel.createPVPConfig(newSeasonNum, newSeasonStartTime, newSeasonStartTime + during - rewardTime, newSeasonStartTime + during - PER_MINUTE);
     }
-    await setPvpSeasonMakeRewardJob(pvpConfig);
+    await setPvpSeasonMakeRewardJob(oldPvpConfig);
     await setNextSeasonJob(pvpConfig);
+    setPvpSeasonNum(pvpConfig);
+    return pvpConfig;
+}
+
+function setPvpSeasonNum(pvpConfig: PVPConfigType) {
+    if(pvpConfig) {
+        pinus.app.set('pvpSeasonNum', pvpConfig.seasonNum);
+        pinus.app.set('pvpSeasonEndTime', pvpConfig.seasonEndTime);
+        pinus.app.rpc.battle.battleRemote.setPvpSeasonNum.broadcast(pvpConfig);
+        pinus.app.rpc.role.roleRemote.setPvpSeasonNum.broadcast(pvpConfig);
+    }
 }
 
 async function setPvpSeasonMakeRewardJob(pvpConfig: PVPConfigType) {
@@ -121,7 +139,7 @@ async function setNextSeasonJob(pvpConfig: PVPConfigType) {
         seasonRefreshTimeJobId.cancel();
     }
     //定时开启新赛季，比seasonEndTime多定一分钟，保证定时器时间没错
-    seasonRefreshTimeJobId = scheduleJob('seasonRefreshTimeJobId', pvpConfig.seasonEndTime + PER_MINUTE, setPvpSeason);
+    seasonRefreshTimeJobId = scheduleJob('seasonRefreshTimeJobId', pvpConfig.seasonEndTime + PER_MINUTE, setPvpSeasonJob);
 }
 
 /**
@@ -129,8 +147,7 @@ async function setNextSeasonJob(pvpConfig: PVPConfigType) {
  * @param hour 
  */
 export async function resetPvpSeasonTime(hour: number) {
-    await PVPConfigModel.setCurPvpConfig({ seasonEndTime: <number>getTimeFun().getDayZeroPoint(0) });
+    return await setPvpSeason(true);
-    return await setPvpSeason();
 }
 
 export async function reportOnlineSchedule() {

shared/db/PvpDefense.ts

@@ -149,7 +149,10 @@ export default class PvpDefense extends BaseModel {
     }
 
     public static async resetScores(roleId: string, newSeasonNum: number, newScore: number, newHeroScores: HeroScore[]) {
-        let result: PvpDefenseType = await PvpDefenseModel.findOneAndUpdate({roleId}, {$set: { seasonNum: newSeasonNum, score: newScore, heroScores: newHeroScores, challengeCnt: PVP.PVP_CHALLENGE_COUNTS, challengeRefTime: 0, winStreakNum: 0 }}, {new: true}).lean();
+        let result: PvpDefenseType = await PvpDefenseModel.findOneAndUpdate({roleId}, {$set: { seasonNum: newSeasonNum, score: newScore, heroScores: newHeroScores, challengeCnt: PVP.PVP_CHALLENGE_COUNTS, challengeRefTime: 0, winStreakNum: 0 }}, {new: true})
+        .populate('role', 'roleId roleName head frame spine heads frames spines title lv vLv')
+        .populate('oppPlayers.oppDef', 'oppRoleId pos roleName head frame spine heads frames spines rankLv pLv title lv defCe heroes warId buff').lean({ getters: true, virtuals: true })
+        .lean();
         return result;
     }
 

shared/db/PvpSeasonResult.ts

@@ -39,11 +39,12 @@ export default class PvpSeasonResult extends BaseModel {
     newHeroScores: HeroScore[];
 
     public static async updatePvpSeasonResult(roleId: string, seasonNum: number, update: PvpSeasonResultUpdate , lean = true) {
+        delete update._id;
         let result: PvpSeasonResultType = await PvpSeasonResultModel.findOneAndUpdate({roleId, seasonNum}, {$set: update}, {upsert: true, new: true}).lean(lean);
         return result;
     }
-    public static async getPvpSeasonResult(roleId: string, seasonNum: number, lean = true) {
+    public static async getPvpSeasonResult(roleId: string) {
-        let result: PvpSeasonResultType = await PvpSeasonResultModel.findOne({ roleId, seasonNum }).lean(lean);
+        let result: PvpSeasonResultType = await PvpSeasonResultModel.findOne({ roleId, show: true }).lean();
         return result;
     }
 }

shared/domain/battleField/guild.ts

@@ -4,6 +4,8 @@ import { RoleType } from "../../db/Role";
 import { WAR_TYPE } from "../../consts";
 import { gameData } from "../../pubUtils/data";
 import { EXTERIOR } from "../../pubUtils/dicParam";
+import { HeroType } from "../../db/Hero";
+import { PvpDefenseType } from "../../db/PvpDefense";
 
 export class PlayerDetailHero {
     actorId: number;
@@ -12,7 +14,8 @@ export class PlayerDetailHero {
     star: number;
     colorStar: number;
     quality: number;
-    score: number;
+    score: number = 0;
+    isDefense: boolean;
 
     setPvpHeroInfo?(hero: PvpEnemies|PvpOtherHeroes) {
         this.actorId = hero.actorId;
@@ -23,6 +26,37 @@ export class PlayerDetailHero {
         this.quality = hero.quality;
         this.score = hero.score;
     }
+
+    setByDbHero?(hero: HeroType) {
+        if(!hero) return;
+
+        this.actorId = hero.hid;
+        this.lv = hero.lv;
+        this.star = hero.star;
+        this.colorStar = hero.colorStar;
+        this.quality = hero.quality;
+        this.skinId = hero.skinId;
+
+    }
+
+    setPvpDefense?(pvpDefense: PvpDefenseType) {
+        if(!pvpDefense) return;
+
+        let { heroScores, defense } = pvpDefense;
+        let heroScore = heroScores.find(cur => cur.hid == this.actorId);
+        this.score = heroScore? heroScore.score: 0;
+
+        if(defense && defense.heroes) {
+            let h = defense.heroes.find(cur => cur.actorId == this.actorId);
+            if(!!h) this.isDefense = true;
+        } else {
+            this.isDefense = false;
+        }
+    }
+
+    setIsDefense?(isDefense: boolean) {
+        this.isDefense = isDefense;
+    }
 }
 
 class PlayerDetailBattle {

shared/domain/dbGeneral.ts

@@ -77,7 +77,7 @@ export class Enemies extends PvpHeroInfo {
     @prop({ required: false })
     y: number; // 战场y坐标
     @prop({ required: false })
-    direction: number; // 朝向
+    dirction: number; // 朝向
     @prop({ required: false })
     var: number; // 变量
     @prop({ required: false })
@@ -99,7 +99,7 @@ export class Enemies extends PvpHeroInfo {
         this.outIndex = heroInfo.outIndex != undefined ? heroInfo.outIndex : warjson.outIndex;
         this.x = warjson.x;
         this.y = warjson.y;
-        this.direction = warjson.direction;
+        this.dirction = warjson.dirction;
         this.var = warjson.var;
         this.lv = heroInfo.lv != undefined ? heroInfo.lv : warjson.lv;
         this.hide = warjson.hide;

shared/domain/rank.ts

@@ -316,6 +316,7 @@ export class KeyName {
     guildCode?: string;
     cityId?: number;
     hid?: number;
+    seasonNum?: number;
 
     constructor(key: string, param: KeyNameParam) {
         this.key = key;
@@ -323,6 +324,7 @@ export class KeyName {
         if(param.guildCode) this.guildCode = param.guildCode;
         if(param.cityId) this.cityId = param.cityId;
         if(param.hid) this.hid = param.hid;
+        if(param.seasonNum) this.seasonNum = param.seasonNum;
     }
 
     public getName() {
@@ -331,6 +333,7 @@ export class KeyName {
         if(this.guildCode) res += `:${this.guildCode}`;
         if(this.cityId) res += `:${this.cityId}`;
         if(this.hid) res += `:${this.hid}`;
+        if(this.seasonNum) res += `:${this.seasonNum}`;
         return res;
     }
 

shared/pubUtils/data.ts

@@ -460,6 +460,7 @@ export function getPvpHeroRewardsByScore(score: number) {
 }
 
 export function getPvpRankRewardsByRank(rankLv: number) {
+    if(rankLv == 0) return null
     for (let item of gameData.pvpRankRewards) {
         if ((item.max >= rankLv || item.max == -1) && rankLv >= item.min) {
             return item;

shared/pubUtils/dictionary/DicPvpRankReward.ts

@@ -21,7 +21,7 @@ export function loadPvpRankReward() {
 
     arr.forEach(o => {
         o.reward = parseGoodStr(o.reward);
-        if (!dicRankMax.max||o.min > dicRankMax.max.min) {
+        if (!dicRankMax.max || o.min > dicRankMax.max.min) {
             dicRankMax.max = o;
         }
         dicRankRewads.push(o);

shared/pubUtils/dictionary/DicWarJson.ts

@@ -14,7 +14,7 @@ export interface DicWarJson {
     // 角色属于我方/敌方/友军
     readonly relation: number;
     // 上阵时的方向
-    readonly direction: number;
+    readonly dirction: number;
     // 客户端存入数组的顺序
     readonly outIndex: number;
     // x坐标