pvp：修改接口

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

@@ -2,28 +2,29 @@
 import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
 import { uniq, findWhere, findIndex } from 'underscore';
 import { gameData, getPvpBoxs, getPLvByScore } from '../../../pubUtils/data';
-import { refreshEnemies, getEnemies, getLvByScore, comsumeChallengeCnt, refChallengeCnt, generPVPOppRecInfo, generMyRecInfo, sendLastSeasonRewardIfNotSent, refreshRefOppCnt } from '../../../services/pvpService';
+import { refreshEnemies, getEnemies, getLvByScore, comsumeChallengeCnt, refChallengeCnt, generPVPOppRecInfo, generMyRecInfo, sendLastSeasonRewardIfNotSent, refreshRefOppCnt, generPvpLineupCe } from '../../../services/pvpService';
 import { RoleModel, RoleType } from '../../../db/Role';
 import { STATUS } from '../../../consts/statusCode';
 import { resResult, genCode, checkRoleIsRobot, robotIdComBack } from '../../../pubUtils/util';
 import { PvpDefenseModel, pvpUpdateInter } from '../../../db/PvpDefense';
-import { pvpEndParamInter } from '../../../pubUtils/interface';
-import { PlayerDetail, PlayerDetailHero } from '../../../domain/battleField/guild';
-import { PVP_HERO_POS, PVP_HERO_ORDER, REDIS_KEY, LINEUP_NUM, TASK_TYPE, COUNTER } from '../../../consts';
-import { PVP } from '../../../pubUtils/dicParam';
-import { addItems } from '../../../services/rewardService';
-import { HeroModel } from '../../../db/Hero';
-import { checkBattleHeroesByHid } from '../../../services/normalBattleService';
-import { BattleRecordModel } from '../../../db/BattleRecord';
-import { PvpRecordModel } from '../../../db/PvpRecord';
-import { handleCost } from '../../../services/rewardService';
-import { nowSeconds, getSeconds } from '../../../pubUtils/timeUtil';
 import { PvpSeasonResultModel } from '../../../db/PvpSeasonResult';
-import { PvpHistoryOppModel, PvpHistoryOppType } from '../../../db/PvpHistoryOpp';
 import { PVPConfigModel } from '../../../db/SystemConfig';
 import { Rank } from '../../../services/rankService';
 import { checkActivityTask, checkTask, checkTaskInPvpEnd } from '../../../services/taskService';
-import { PvpDataReturn } from '../../../domain/battleField/pvp';
+import { Attack, AttackHero, Defense, DefenseHero, PvpDataReturn } from '../../../domain/battleField/pvp';
+import { LINEUP_NUM, REDIS_KEY, TASK_TYPE } from '../../../consts';
+import { PVP } from '../../../pubUtils/dicParam';
+import { getGoldObject } from '../../../pubUtils/itemUtils';
+import { addItems, handleCost } from '../../../services/rewardService';
+import { pick } from "underscore";
+import { HeroModel } from '../../../db/Hero';
+import PvpHistoryOpp, { PvpHistoryOppModel } from '../../../db/PvpHistoryOpp';
+import { checkBattleHeroesByHid } from '../../../services/normalBattleService';
+import { BattleRecordModel } from '../../../db/BattleRecord';
+import { PvpRecordModel } from '../../../db/PvpRecord';
+import { pvpEndParamInter } from '../../../pubUtils/interface';
+import { getSeconds, nowSeconds } from '../../../pubUtils/timeUtil';
+import { PlayerDetail, PlayerDetailHero } from '../../../domain/battleField/guild';
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -43,83 +44,90 @@ export class PvpHandler {
             let role = await RoleModel.findByRoleId(roleId);
             pvpDefense = await PvpDefenseModel.createPvpDefense({ roleId: role.roleId, roleName: role.roleName, role: role._id });
         }
+        // 如果没有发过，将上赛季的奖励发下
         pvpDefense = await sendLastSeasonRewardIfNotSent(pvpDefense);
         let { seasonNum, seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
 
-        
+        let update: pvpUpdateInter = { };
+        let result = new PvpDataReturn(); // 返回对象
+        // 刷新次数
         let refChallengeObj = refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
-        let refOppObj = refreshRefOppCnt(pvpDefense.refOppCnt, pvpDefense.refDaily);
-
-        let update: pvpUpdateInter = { ...refChallengeObj, ...refOppObj};
-        
-        let result = new PvpDataReturn(pvpDefense); // 返回对象
-        
+        if(refChallengeObj.hasChanged) {
+            update = { ...update, ...refChallengeObj }
+        }
+        let refOppObj = refreshRefOppCnt(pvpDefense.refOppCnt, pvpDefense.setAttackCnt, pvpDefense.refDaily);
+        // 每天首次打开要刷掉对手
         if(refOppObj.shouldRefOpp) {
-            let role = <RoleType>pvpDefense.role;
-            let oppPlayers = await refreshEnemies(role, seasonNum, pvpDefense.score, pvpDefense.attack.pLv);
-            update.oppPlayers = oppPlayers;
-            let oppPlayersReturn = await getEnemies(oppPlayers||[], pvpDefense.winStreakNum);
-            result.setOppPlayers(oppPlayersReturn);
-        } else {
-            let oppPlayersReturn = await getEnemies(pvpDefense.oppPlayers||[], pvpDefense.winStreakNum);
-            result.setOppPlayers(oppPlayersReturn);
+            if(pvpDefense.attack) {
+                let role = <RoleType>pvpDefense.role;
+                let oppPlayers = await refreshEnemies(role, seasonNum, pvpDefense.score, pvpDefense.attack.pLv||1);
+                update.oppPlayers = oppPlayers;
+            }
+            update = { ...update, ...refOppObj }
         }
 
-        let { score, winStreakNum, refOppCnt, challengeCnt, challengeRefTime, receivedBox, hisScore, heroScores, isFirstEntry } = pvpDefense;
         if (pvpDefense.isFirstEntry) {
             update.isFirstEntry = false;
+            result.setIsFirstEntry(true);
+        }
+        
+        if(Object.keys(update).length > 0) {
+            pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, update);
         }
-        let pvpSeasonResult = await PvpSeasonResultModel.getPvpSeasonResult(roleId, pvpDefense.seasonNum);
 
         result.setPvpConfig(seasonNum, seasonEndTime);
-        
+        result.setPvpDefense(pvpDefense);
+
+        let oppPlayersReturn = await getEnemies(pvpDefense.oppPlayers||[], pvpDefense.winStreakNum);
+        result.setOppPlayers(oppPlayersReturn);
+        // 赛季结算
+        let pvpSeasonResult = await PvpSeasonResultModel.getPvpSeasonResult(roleId, pvpDefense.seasonNum);
         if (!!pvpSeasonResult && !!pvpSeasonResult.show) {
             result.setPvpSeasonResult(pvpSeasonResult);
             await PvpSeasonResultModel.updatePvpSeasonResult(roleId, pvpSeasonResult.seasonNum, { show: false });
         }
-
+        // 拍卖
         let r = new Rank(REDIS_KEY.PVP_RANK, {});
         let myRank = await r.getMyRank({ roleId });//去redis中获取排名
         result.setMyRank(myRank);
 
-        // let data: any = {
-        //     warId, seasonNum, seasonEndTime, myRank, oppPlayers, heroes: heroes.map(cur => {
-        //         let { actorId, dataId, order } = cur;
-        //         return { actorId, dataId, order }
-        //     }), score, pLv, winStreakNum, refOppCnt, challengeCnt, challengeRefTime, receivedBox, hisScore, heroScores, isFirstEntry, isDefaultHero
-        // }
-
         return resResult(STATUS.SUCCESS, result);
     }
 
-    /*
     // 刷新对手
     async refreshOppPlayer(msg: {}, session: BackendSession) {
         let roleId = session.get('roleId');
         let sid = session.get('sid');
 
         let pvpDefense = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
+        if(!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
+        if(!pvpDefense.attack) return resResult(STATUS.PVP_NOT_SET_ATTACK);
 
         // 刷新次数及消耗
-        let { refOppCnt, refOppTime, consume } = getRefOppCnt(pvpDefense.refOppCnt, pvpDefense.refOppTime);
-        if (refOppCnt >= gameData.maxPvpRefreshCnt.max) {
+        let refOppObj = refreshRefOppCnt(pvpDefense.refOppCnt, pvpDefense.setAttackCnt, pvpDefense.refDaily);
+        if (refOppObj.refOppCnt >= gameData.maxPvpRefreshCnt.max) {
             return resResult(STATUS.PVP_REFRESH_CNT_REACH_MAX);
         }
 
-        let costResult = await handleCost(roleId, sid, consume);
+        let costResult = await handleCost(roleId, sid, refOppObj.consume);
         if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
+        refOppObj.refOppCnt ++;
 
         // 刷新对手
         let role = <RoleType>pvpDefense.role;
-        let oppPlayers = await refreshEnemies(role, pvpDefense.score, pvpDefense.pLv);
+        let { seasonNum } = await PVPConfigModel.findCurPVPConfig();
+        let oppPlayers = await refreshEnemies(role, seasonNum, pvpDefense.score, pvpDefense.attack.pLv||1);
 
-        pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { oppPlayers, refOppCnt: refOppCnt + 1, refOppTime });
-        let result = await getEnemies(pvpDefense.oppPlayers, pvpDefense.winStreakNum);
+        pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { oppPlayers, ...refOppObj });
 
+        let result = new PvpDataReturn(); // 返回对象
+        result.setPvpDefense(pvpDefense);
+        let oppPlayersReturn = await getEnemies(pvpDefense.oppPlayers, pvpDefense.winStreakNum);
+        result.setOppPlayers(oppPlayersReturn);
 
-        return resResult(STATUS.SUCCESS, { oppPlayers: result, refOppCnt: pvpDefense.refOppCnt });
+        return resResult(STATUS.SUCCESS, pick(result, ['oppPlayers', 'refOppCnt', 'setAttackCnt']));
     }
-
+    
     // 获取对手阵容具体信息
     async getOppPlayer(msg: { roleId: string }, session: BackendSession) {
         let roleId = session.get('roleId');
@@ -131,14 +139,15 @@ export class PvpHandler {
         let curOpp = oppPlayers.find(cur => cur.roleId == oppoRoleId);
         if (!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND);
 
-        let { oppRoleId, heroes } = <PvpHistoryOppType>curOpp.oppDef;
+        let pvpHistoryOpp = <PvpHistoryOpp>curOpp.oppDef;
 
-        return resResult(STATUS.SUCCESS, { roleId: oppRoleId, pos: curOpp.pos, heroes });
+        return resResult(STATUS.SUCCESS, { roleId: pvpHistoryOpp.oppRoleId, ...pick(pvpHistoryOpp, ['pos', 'warId', 'buff', 'heroes']) });
     }
 
+    
     // 开战
-    async pvpStart(msg: { warId: number, heroes: number[], roleId: string }, session: BackendSession) {
-        const { warId, heroes, roleId: oppRoleId } = msg;
+    async pvpStart(msg: { warId: number, roleId: string }, session: BackendSession) {
+        const { warId, roleId: oppRoleId } = msg;
         let roleId = session.get('roleId');
         let roleName = session.get('roleName');
 
@@ -147,10 +156,7 @@ export class PvpHandler {
             return resResult(STATUS.BATTLE_MISS_INFO);
         }
 
-        let { isOK } = await checkBattleHeroesByHid(roleId, heroes);
-        if (!isOK) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
-
-        const pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
+        let pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
         if (!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
         // 检查挑战次数
         let { seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
@@ -164,6 +170,7 @@ export class PvpHandler {
         if (!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND)
 
         const battleCode = genCode(8); // 关卡唯一值
+        let heroes = pvpDefense.attack.heroes.map(cur => cur.actorId);
 
         await BattleRecordModel.updateBattleRecordByCode(battleCode, {
             $set: {
@@ -205,26 +212,28 @@ export class PvpHandler {
         if (!flag) return resResult(STATUS.BATTLE_INFO_VALIDATE_ERR);
 
         // 更新军功
-        let { pvpDefense, warId } = await findPvpDefByRoleId(roleId);
+        let pvpDefense = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
         if (!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
-        let { oppPlayers, winStreakNum, heroScores, score, hisScore } = pvpDefense;
-        let curOpp = oppPlayers.find(cur => cur.roleId == oppRoleId && cur.pos == pos);
-        if (!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND);
+
+        let update: pvpUpdateInter = {};
 
         const role = await RoleModel.findByRoleId(roleId, null, true);
         if (isSuccess) {
-            winStreakNum++;
+            update.winStreakNum = pvpDefense.winStreakNum + 1;
         } else {
-            winStreakNum = 0;
+            update.winStreakNum = 0;
         }
 
-        const myRecInfo = await generMyRecInfo(heroScores, winStreakNum, role, isSuccess, pos, myHeroes);
-
-        let { attackInfo, showHeroScores, addSumScore } = myRecInfo
-
-        score += addSumScore;
-        let pLv = getLvByScore(heroScores);
+        const myRecInfo = await generMyRecInfo(pvpDefense.heroScores, pvpDefense.winStreakNum, role, isSuccess, pos, myHeroes);
+        let { attackInfo, showHeroScores, addSumScore, newHeroScore } = myRecInfo
+        update.heroScores = newHeroScore;
+        update.score = pvpDefense.score + addSumScore;
+        if (pvpDefense.hisScore < update.score) {
+            update.hisScore = update.score;
+        }
 
+        let curOpp = pvpDefense.oppPlayers.find(cur => cur.roleId == oppRoleId && cur.pos == pos);
+        if (!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND);
         const defenseInfo = await generPVPOppRecInfo(isSuccess, curOpp, oppHeroes, role.lv);
 
         // 战报记录
@@ -234,130 +243,150 @@ export class PvpHandler {
         await PvpHistoryOppModel.setStatus(roleId, oppRoleId, 1);
 
         // 刷新对手
-        let newOppPlayers: Array<OppPlayers> = await refreshEnemies(role, score, pLv);
+        let { seasonNum, seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
+        let oppPlayers = await refreshEnemies(role, seasonNum, pvpDefense.score, pvpDefense.attack.pLv||1);
+        update.oppPlayers = oppPlayers;
 
         // 更新battleRecord
         await BattleRecordModel.updateBattleRecordByCode(battleCode, {
             $set: { status: isSuccess ? 1 : 2 }
         }, true);
-        let { seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
 
         // 减少挑战次数
-        if (hisScore < score) {
-            hisScore = score;
-        }
-        pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { oppPlayers: newOppPlayers, heroScores, score, pLv, winStreakNum, challengeCnt: pvpDefense.challengeCnt - 1, hisScore });
-        let result = await getEnemies(pvpDefense.oppPlayers, pvpDefense.winStreakNum);
+        let refChallengeObj = refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
+        refChallengeObj.challengeCnt --;
+        update = {...update, ...refChallengeObj};
+
+        pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, update);
+
+
+        let result = new PvpDataReturn(); // 返回对象
+        result.setPvpDefense(pvpDefense);
+        let oppPlayersReturn = await getEnemies(pvpDefense.oppPlayers, pvpDefense.winStreakNum);
+        result.setOppPlayers(oppPlayersReturn);
 
         // 加入排行榜
         let r = new Rank(REDIS_KEY.PVP_RANK, {});
         await r.setRankWithRoleInfo(roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), role);
         let myRank = await r.getMyRank({ roleId });
+        result.setMyRank(myRank);
 
-        await checkTaskInPvpEnd(roleId, sid, isSuccess, heroScores);
+        await checkTaskInPvpEnd(roleId, sid, isSuccess, pvpDefense.heroScores);
         await checkActivityTask(serverId, sid, roleId, TASK_TYPE.PVP, 1)
         if (isSuccess) {
             await checkActivityTask(serverId, sid, roleId, TASK_TYPE.PVP_WIN, 1)
             await checkActivityTask(serverId, sid, roleId, TASK_TYPE.PVP_WIN_SERIES, 1)
         }
 
+
         return resResult(STATUS.SUCCESS, {
             battleCode, isSuccess,
-            score, pLv, myRank, hisScore,
             heroScores: showHeroScores,
-            oppPlayers: result,
-            refOppCnt: pvpDefense.refOppCnt,
-            challengeCnt: pvpDefense.challengeCnt,
-            challengeRefTime: pvpDefense.challengeRefTime,
-            winStreakNum: pvpDefense.winStreakNum,
-            warId
+            ...pick(result, ['score', 'myRank', 'winStreakNum', 'attack', 'oppPlayers', 'challengeCnt', 'challengeRefTime'])
         });
     }
 
+    async saveAttack(msg: { heroes: { actorId: number, order: number }[] }, session: BackendSession) {
+        let { heroes } = msg;
+        let roleId = session.get('roleId');
+        let sid = session.get('sid');
+
+        if (heroes.length > LINEUP_NUM || heroes.length <= 0) {
+            return resResult(STATUS.WRONG_PARMS);
+        }
+
+        let pvpDefense = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
+        if(!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
+
+        // 次数
+        let refOppObj = refreshRefOppCnt(pvpDefense.refOppCnt, pvpDefense.setAttackCnt, pvpDefense.refDaily);
+        if(refOppObj.setAttackCnt >= PVP.PVP_SET_ATTACK_CNT) {
+            return resResult(STATUS.PVP_SET_ATTACK_CNT_NOT_ENOUGH);
+        }
+        if(refOppObj.setAttackCnt >= PVP.PVP_SET_ATTACK_FREE_CNT) {
+            let gold = getGoldObject(PVP.PVP_SET_ATTACK_CNT_GOLD);
+            let result = await handleCost(roleId, sid, [gold]);
+            if(!result) return resResult(STATUS.TOWER_GOLD_NOT_ENOUGH);
+        }
+        refOppObj.setAttackCnt ++;
+        let { seasonNum, seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
+        let refChallengeObj = refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
+        // 刷对手
+        let role = <RoleType>pvpDefense.role;
+        let oppPlayers = await refreshEnemies(role, seasonNum, pvpDefense.score, pvpDefense.attack?.pLv||1);
+        // 更新挑战阵容
+        let score = 0;
+        for(let { actorId } of heroes) {
+            let heroScore = pvpDefense.heroScores.find(cur => cur.hid == actorId);
+            if(heroScore) {
+                score += heroScore.score;
+            }
+        }
+        let attack = new Attack(heroes, score);
+        let lineupCe = await generPvpLineupCe(roleId, pvpDefense.lineupCe, attack.heroes, []);
+        // 保存
+        pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { ...refOppObj, ...refChallengeObj, attack, oppPlayers, lineupCe });
+        // 返回
+        let result = new PvpDataReturn();
+        result.setPvpDefense(pvpDefense);
+        let oppPlayersReturn = await getEnemies(pvpDefense.oppPlayers||[], pvpDefense.winStreakNum);
+        result.setOppPlayers(oppPlayersReturn);
+
+        return resResult(STATUS.SUCCESS, pick(result, ['attack', 'oppPlayers', 'setAttackCnt', 'challengeCnt', 'challengeRefTime']));
+    }
+
     //3. 保存防守阵容
-    async saveDefense(msg: { heroes: Array<{ actorId: number, dataId: number, order: number }>, isDefaultHero: boolean }, session: BackendSession) {
-        let { heroes, isDefaultHero } = msg;
+    async saveDefense(msg: { heroes: { actorId: number, dataId: number, order: number, ai: number }[], warId: number, buff: number }, session: BackendSession) {
+        let { heroes, warId, buff } = msg;
         let roleId = session.get('roleId');
         if (heroes.length > LINEUP_NUM || heroes.length <= 0) {
             return resResult(STATUS.WRONG_PARMS);
         }
-        heroes = uniq(heroes, function (item) {
-            return item.order;
-        });
+
+        let pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
+        if(!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
+        // 刷新次数
         let { seasonEndTime } = await PVPConfigModel.findCurPVPConfig();
-        let { heroes: defHeros, challengeCnt: lastChallengeCnt, challengeRefTime: lastChallengeRefTime } = await PvpDefenseModel.findByRoleId(roleId);
-        let defCe = 0;
-        let { challengeCnt, challengeRefTime } = refChallengeCnt(lastChallengeCnt, lastChallengeRefTime, seasonEndTime);
-
-        if (!!isDefaultHero) {
-            let { topLineup } = await RoleModel.findByRoleId(roleId);
-            let hids = topLineup.filter(cur => {
-                return !heroes.find(ccur => ccur.actorId == cur.hid);
-            }).map(cur => cur.hid);
-            let dataIds = new Array<number>(), orders = new Array<number>();
-
-            for (let hero of heroes) {
-                if (hero.actorId) {
-                    let isInTop = topLineup.find(cur => cur.hid == hero.actorId);
-                    if (!isInTop) {
-                        hero.actorId = hids.shift();
-                    }
-                    dataIds.push(hero.dataId);
-                    orders.push(hero.order);
-                }
+        let refChallengeObj = refChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
+        // 更新防守阵容
+        let score = 0, heroIdMap = new Map<number, string>(), hids: number[] = [];
+        for(let { actorId } of heroes) {
+            let heroScore = pvpDefense.heroScores.find(cur => cur.hid == actorId);
+            if(heroScore) {
+                score += heroScore.score;
             }
-            for (let hid of hids) {
-                let dataId = 0;
-                for (let i = PVP_HERO_POS.START; i <= PVP_HERO_POS.END; i++) {
-                    if (dataIds.includes(i)) continue;
-                    dataIds.push(i);
-                    dataId = i; break;
+            // 记录hero的objectId，用于存defense.heroes.hero
+            if(pvpDefense.defense && pvpDefense.defense.heroes) {
+                let heroInDefense = pvpDefense.defense.heroes.find(cur => cur.actorId == actorId);
+                if(heroInDefense) {
+                    heroIdMap.set(actorId, <string>heroInDefense.hero);
+                } else {
+                    hids.push(actorId);
                 }
-                let order = 0;
-                for (let i = PVP_HERO_ORDER.START; i <= PVP_HERO_ORDER.END; i++) {
-                    if (orders.includes(i)) continue;
-                    orders.push(i);
-                    order = i; break;
-                }
-                heroes.push({
-                    actorId: hid, dataId, order
-                })
+            } else {
+                hids.push(actorId);
             }
         }
-
-        for (let dataId = PVP_HERO_POS.START; dataId <= PVP_HERO_POS.END; dataId++) {
-            let index = findIndex(heroes, { dataId });
-            let defIndex = findIndex(defHeros, { dataId });
-            if (defIndex == -1) {
-                defIndex = defHeros.length;
-                defHeros.push({ actorId: 0, order: 0, ce: 0, hero: null, dataId });
-            }
-            if (index == -1) {
-                defHeros[defIndex].actorId = 0;
-                defHeros[defIndex].order = 0;
-                defHeros[defIndex].ce = 0;
-                defHeros[defIndex].hero = null;
-                defHeros[defIndex].dataId = dataId;
-                continue;
-            }
-            if (heroes[index].order < 1 || heroes[index].order > LINEUP_NUM) {
-                return resResult(STATUS.WRONG_PARMS);
-            }
-            let hero = await HeroModel.findByHidAndRole(heroes[index].actorId, roleId);
-            if (!hero) {
-                continue;
-            }
-            defHeros[defIndex].actorId = heroes[index].actorId;
-            defHeros[defIndex].order = heroes[index].order;
-            defHeros[defIndex].ce = hero.ce;
-            defHeros[defIndex].hero = hero._id;
-            defCe += hero.ce;
+        let dbHeroes = await HeroModel.findByHidRange(hids, roleId, '_id hid ce', true);
+        for(let hero of dbHeroes) {
+            heroIdMap.set(hero.hid, hero._id);
         }
-        let { heroes: resHeroes } = await PvpDefenseModel.updateInfo(roleId, { defCe, heroes: defHeros, challengeCnt, challengeRefTime, isDefaultHero });
-        return resResult(STATUS.SUCCESS, { heroes: resHeroes, challengeCnt, challengeRefTime, isDefaultHero });
 
+        let defenseHeroes = heroes.map(cur => {
+            return new DefenseHero(cur, heroIdMap.get(cur.actorId));
+        });
+        let defense = new Defense(defenseHeroes, score, warId, buff);
+        let lineupCe = await generPvpLineupCe(roleId, pvpDefense.lineupCe, defense.heroes, dbHeroes);
+
+        pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { ...refChallengeObj, defense, lineupCe });
+        // 返回
+        let result = new PvpDataReturn();
+        result.setPvpDefense(pvpDefense);
+        
+        return resResult(STATUS.SUCCESS, pick(result, ['defense', 'challengeCnt', 'challengeRefTime']));
     }
 
+    
     //8. 排行榜
     async getRank(msg: {}, session: BackendSession) {
 
@@ -369,7 +398,7 @@ export class PvpHandler {
         if (!myRank) {
             let pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
 
-            myRank = await r.generMyRankWithRole(roleId, pvpDefense.score, getSeconds(pvpDefense.refOppTime));
+            myRank = await r.generMyRankWithRole(roleId, pvpDefense.score, getSeconds(pvpDefense.refDaily));
         }
 
         return resResult(STATUS.SUCCESS, { ranks, myRank });
@@ -487,9 +516,7 @@ export class PvpHandler {
         if (hisScore < score) {
             hisScore = score;
         }
-        let pLv = getPLvByScore(score);
-        let pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { score, hisScore, pLv, heroScores });
-        let roleName = session.get('roleName');
+        let pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { score, hisScore, heroScores });
         const role = await RoleModel.findByRoleId(roleId);
 
         // 加入排行榜
@@ -501,7 +528,7 @@ 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();
@@ -519,6 +546,7 @@ export class PvpHandler {
         return resResult(STATUS.SUCCESS, { seasonNum, seasonEndTime });
     }
 
+    */
     async debugAddChallengeCnt(msg: { challengeCnt: number }, session: BackendSession) {
         let { challengeCnt } = msg;
         let roleId = session.get('roleId');
@@ -529,5 +557,4 @@ export class PvpHandler {
         return resResult(STATUS.SUCCESS, { challengeCnt, challengeRefTime });
     }
 
-    */
 }

game-server/app/services/pvpService.ts

@@ -1,6 +1,6 @@
 
 import { PvpDefenseModel, PvpDefenseType, pvpUpdateInter } from '../db/PvpDefense';
-import { Defense, Attack, LineupCe, OppPlayer, HeroScore, HeroReward, OppPlayerReturn } from '../domain/battleField/pvp';
+import { Defense, Attack, LineupCe, OppPlayer, HeroScore, HeroReward, OppPlayerReturn, AttackHero, DefenseHero } from '../domain/battleField/pvp';
 import { RoleType, CeAttrDataRole } from '../db/Role';
 import { PVP_HERO_POS, REDIS_KEY, PVP_CONST, COUNTER, TASK_TYPE, MAIL_TYPE } from '../consts';
 import { dicPvpOpponent, DicPvpOpponent } from "../pubUtils/dictionary/DicPvpOpponent";
@@ -11,7 +11,7 @@ import { PVP } from '../pubUtils/dicParam';
 import { PVPConfigModel, PVPConfigType } from '../db/SystemConfig'
 import { nowSeconds, getTimeFun } from '../pubUtils/timeUtil';
 import { HeroesRecord } from '../db/PvpRecord';
-import { HeroModel, CeAttrData } from '../db/Hero';
+import { HeroModel, CeAttrData, HeroType } from '../db/Hero';
 import { AttributeCal } from '../domain/roleField/attribute';
 import { PvpEnemies, PvpHeroInfo, PvpOtherHeroes } from '../domain/dbGeneral';
 import { DicWarJson } from '../pubUtils/dictionary/DicWarJson';
@@ -37,6 +37,8 @@ export async function getEnemies(oppPlayers: OppPlayer[], winStreakNum: number)
     for (let oppPlayer of oppPlayers) {
         let dicOpponent = dicPvpOpponent.get(oppPlayer.pos);
         let oppDef = <PvpHistoryOppType>oppPlayer.oppDef; // select 'oppRoleId pos roleName head frame spine rankLv pLv defCe'
+console.log('*******', oppDef)
+
         if (oppDef) delete oppDef.heroes;
         result.push({
             ...oppDef,
@@ -239,10 +241,10 @@ async function matchRobot(oppPlayers: OppPlayer[], role: RoleType, pLv: number,
         let dicHero = gameData.hero.get(actorId);
         if (!dicHero) continue;
         let heroInfo = new PvpHeroInfo();
-        heroInfo.setRobotInfo(h, actorId, myLv, dicHero.initialStars, dicHero.quality);
+        heroInfo.setRobotInfo(actorId, myLv);
         let { attribute, ce } = getRobotAttribute(h.attribute, h.enemyCount, [], pLv, myCe, PVP_CONST.ENEMY_CE, ratio);
         defCe += ce;
-        heroInfo.setAttribute(attribute);
+        heroInfo.setAttribute("1&3500|2&500|4&400|5&400|9&0|10&0|11&0|12&0|13&0|14&10000|18&0");
         let enemy = new PvpEnemies(h, heroInfo, 0, ce);
         heroes.push(enemy);
     }
@@ -253,7 +255,7 @@ async function matchRobot(oppPlayers: OppPlayer[], role: RoleType, pLv: number,
     if (hisPLv < 1) hisPLv = 1
 
     let pvpHistoryOpp = await PvpHistoryOppModel.createPvpOpp({
-        roleId, oppRoleId, roleName, pos, defCe, pLv: hisPLv, lv: myLv, heroes, rankLv: 0
+        roleId, oppRoleId, roleName, pos, defCe, pLv: hisPLv, lv: myLv, heroes, rankLv: 0, warId: result.war_id, buff: getRandSingleEelm(result.mapseid)||0,
     });
 
     oppPlayers.push({
@@ -289,8 +291,9 @@ export function getLvByScore(heroScores: HeroScore[]) {
 }
 
 export function refChallengeCnt(challengeCnt: number, challengeRefTime: number, seasonEndTime: number) {
+    let hasChanged = false;
     if (challengeCnt >= PVP.PVP_CHALLENGE_COUNTS) {
-        return { challengeCnt, challengeRefTime };
+        return { hasChanged, challengeCnt, challengeRefTime };
     }
     let period = PVP.PVP_CHALLENGE_NORMALTIMES * 60;
     if (getTimeFun(seasonEndTime).checkDay()) {
@@ -301,9 +304,10 @@ export function refChallengeCnt(challengeCnt: number, challengeRefTime: number,
     if (num > 0) {
         challengeCnt += num;
         challengeRefTime = challengeRefTime + period * num;
+        hasChanged = true;
     }
     challengeCnt = challengeCnt > PVP.PVP_CHALLENGE_COUNTS ? PVP.PVP_CHALLENGE_COUNTS : challengeCnt;
-    return { challengeCnt, challengeRefTime };
+    return { hasChanged, challengeCnt, challengeRefTime };
 }
 
 export function comsumeChallengeCnt(challengeCnt: number, challengeRefTime: number, seasonEndTime: number) {
@@ -328,15 +332,15 @@ export async function sendLastSeasonRewardIfNotSent(pvpDefense: PvpDefenseType)
 }
 
 // 获取刷新对手次数及消耗
-export function refreshRefOppCnt(refOppCnt: number, refDaily: Date) {
+export function refreshRefOppCnt(refOppCnt: number, setAttackCnt: number, refDaily: Date) {
     let curTime = new Date();
     let shouldRefOpp = shouldRefresh(refDaily, curTime);
     if (shouldRefOpp) {
-        refOppCnt = 0; refDaily = curTime;
+        refOppCnt = 0; setAttackCnt = 0; refDaily = curTime;
     }
     return {
         shouldRefOpp,
-        refOppCnt, refDaily,
+        refOppCnt, refDaily, setAttackCnt,
         consume: gameData.pvpRefreshConsume.get(refOppCnt + 1)
     }
 }
@@ -405,6 +409,7 @@ export async function generMyRecInfo(heroScores: HeroScore[], winStreakNum: numb
     const plusScore = getPlusScore(winStreakNum);
     let pLv = getLvByScore(heroScores);
 
+    // TODO 这里heroScore可以改为不改变原数据，而创建新数据的方式
     let myHeroRecords = new Array<HeroesRecord>();
     let showHeroScores = new Array<{ hid: number, addScore: number, plusScore: number, score: number }>();
     let addSumScore = 0;
@@ -450,7 +455,7 @@ export async function generMyRecInfo(heroScores: HeroScore[], winStreakNum: numb
         score: isSuccess ? addSumScore : 0
     }
 
-    return { attackInfo, showHeroScores, addSumScore }
+    return { attackInfo, showHeroScores, addSumScore, newHeroScore: heroScores }
 }
 
 // 获取对手战报记录
@@ -571,10 +576,28 @@ export async function savePvpSeasonResult(pvpDefense: PvpDefenseType, seasonNum:
     return pvpSeasonResult;
 }
 
-function getScore(arr, score) {
-    for (let item of arr) {
-        if ((item.max >= score || item.max == -1) && score >= item.min) {
-            return item;
+export async function generPvpLineupCe(roleId: string, lineupCe: LineupCe[], newHeroes: AttackHero[]|DefenseHero[], dbHeroes: HeroType[]) {
+    let newHids: number[] = []; // 本次新增武将
+    let newLineupCe: { hid: number, ce: number }[] = []; // 新生成的lineupCe字段
+    for(let { actorId } of newHeroes) {
+        let n = newLineupCe.find(cur => cur.hid == actorId);
+        if(!n) {
+            let lineup = lineupCe.find(cur => cur.hid == actorId);
+            if(lineup) {
+                newLineupCe.push(lineup);
+            } else {
+                let dbHero = dbHeroes.find(cur => cur.hid == actorId);
+                if(dbHero) {
+                    newLineupCe.push({ hid: actorId, ce: dbHero.ce });
+                } else {
+                    newHids.push(actorId);
+                }
+            }
         }
     }
+    let heroes = await HeroModel.findByHidRange(newHids, roleId, 'hid ce', true);
+    for(let { hid, ce } of heroes) {
+        newLineupCe.push({ hid, ce });
+    }
+    return newLineupCe;
 }

game-server/app/services/rankService.ts

@@ -930,17 +930,18 @@ 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 { seasonNum } = await PVPConfigModel.findCurPVPConfig();
-        console.log('execute season resetPvpRanks seasonNum = ' + seasonNum);
-        let ranks = await PvpDefenseModel.getRank(seasonNum);//获得全服前1000名的排名，加入到redis中
-        let r = new Rank(type, {});
-        r.setIsInit(true);
-        for (let { roleId, role: _role, score, updatedAt } of ranks) {
-            let role = <RoleType>_role;
-            if (!role) {
-                continue;
+        let pvpConfig = await PVPConfigModel.findCurPVPConfig();
+        if(pvpConfig) {
+            let ranks = await PvpDefenseModel.getRank(pvpConfig.seasonNum);//获得全服前1000名的排名，加入到redis中
+            let r = new Rank(type, {});
+            r.setIsInit(true);
+            for (let { roleId, role: _role, score, updatedAt } of ranks) {
+                let role = <RoleType>_role;
+                if (!role) {
+                    continue;
+                }
+                await r.setRankWithRoleInfo(roleId, score, updatedAt.getTime(), role);
             }
-            await r.setRankWithRoleInfo(roleId, score, updatedAt.getTime(), role);
         }
     } else if (type == REDIS_KEY.TOP_LINEUP_RANK) {
         let serverId = args.serverId;

game-server/app/services/timeTaskService.ts

@@ -1,7 +1,7 @@
 
 import { scheduleJob, Job, } from 'node-schedule';
 import { PVPConfigModel, PVPConfigType } from '../db/SystemConfig';
-import { nowSeconds, getTimeFun, getZeroPoint } from '../pubUtils/timeUtil';
+import { nowSeconds, getTimeFun } from '../pubUtils/timeUtil';
 import { getTodayGuildActivity, gameData } from '../pubUtils/data';
 import { pvpSeasonEnd } from './pvpService';
 import { getAllOnlineRoles, getAllServers, delGuildActivityRank } from './redisService';
@@ -83,7 +83,7 @@ function getSeasonContinueDay(seasonNum: number) {
 async function setPvpSeason() {
     let pvpConfig = await PVPConfigModel.findCurPVPConfig();
     if(!pvpConfig || pvpConfig.seasonEndTime <= nowSeconds() ) {
-        if(!pvpConfig.hasSettleReward) {
+        if(pvpConfig && !pvpConfig.hasSettleReward) {
             await pvpSeasonEnd(pvpConfig);
         }
 
@@ -94,9 +94,10 @@ async function setPvpSeason() {
         let during = getSeasonContinueDay(lastSeasonNum + 1) * PER_DAY;
         let rewardTime = SETTLE_DIFF_SECONDS;
         if(nowSeconds() - lastSeasonEndTime > during) {
-            newSeasonStartTime = getZeroPoint();
+            newSeasonStartTime = <number>getTimeFun().getDayZeroPoint(0);
         }
-        pvpConfig = await PVPConfigModel.createPVPConfig(lastSeasonNum + 1, newSeasonStartTime, newSeasonStartTime + during - rewardTime, newSeasonStartTime + during - PER_MINUTE);
+        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 setNextSeasonJob(pvpConfig);
@@ -128,7 +129,7 @@ async function setNextSeasonJob(pvpConfig: PVPConfigType) {
  * @param hour 
  */
 export async function resetPvpSeasonTime(hour: number) {
-    await PVPConfigModel.setCurPvpConfig({ seasonEndTime: getZeroPoint() });
+    await PVPConfigModel.setCurPvpConfig({ seasonEndTime: <number>getTimeFun().getDayZeroPoint(0) });
     return await setPvpSeason();
 }