活动：添加新的任务统计

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

@@ -13,7 +13,7 @@ import { getAp, setAp } from '../../../services/actionPointService';
 import { STATUS } from '../../../consts/statusCode';
 import { resResult } from '../../../pubUtils/util';
 import { checkBattleHeroes, roleLevelup } from '../../../services/normalBattleService';
-import { checkTask, checkTaskInBattleEnd } from '../../../services/taskService';
+import { checkActivityTask, checkTask, checkTaskInBattleEnd } from '../../../services/taskService';
 import { gameData } from '../../../pubUtils/data';
 
 export default function (app: Application) {
@@ -292,6 +292,7 @@ export class ExpeditionBattleHandler {
         let roleName = session.get('roleName');
         let sid = session.get('sid');
         const funcs: number[] = session.get('funcs');
+        const serverId = session.get('serverId');
 
         let role = await RoleModel.findByRoleId(roleId);
         let { expeditionPoint } = role;
@@ -331,6 +332,7 @@ export class ExpeditionBattleHandler {
 
         // 任务
         await checkTask(roleId, sid, funcs, TASK_TYPE.BATTLE_EXPEDITION_BOX, 1, true, { point });
+        await checkActivityTask(serverId, sid, funcs, roleId, TASK_TYPE.BATTLE_EXPEDITION_BOX, 1)
 
         let goods = await addItems(roleId, roleName, sid, curDicExpeditionPoint.reward);
 

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

@@ -1,4 +1,4 @@
-import {Application, BackendSession, pinus} from 'pinus';
+import { Application, BackendSession, pinus } from 'pinus';
 import { uniq, findWhere, findIndex } from 'underscore';
 import { gameData, getPvpBoxs, getPLvByScore } from '../../../pubUtils/data';
 import { refreshEnemies, getEnemies, getLvByScore, defaultHeroes, comsumeChallengeCnt, refresh, findPvpDefByRoleId, checkRoleIsRobot, getRefOppCnt, findPvpDefAllByRoleId, generPVPOppRecInfo, generMyRecInfo, robotIdComBack } from '../../../services/pvpService';
@@ -23,9 +23,9 @@ import { PvpSeasonResultModel } from '../../../db/PvpSeasonResult';
 import { PvpHistoryOppModel, PvpHistoryOppType } from '../../../db/PvpHistoryOpp';
 import { SystemConfigModel } from '../../../db/SystemConfig';
 import { Rank } from '../../../services/rankService';
-import { checkTask, checkTaskInPvpEnd } from '../../../services/taskService';
+import { checkActivityTask, checkTask, checkTaskInPvpEnd } from '../../../services/taskService';
 
-export default function(app: Application) {
+export default function (app: Application) {
     return new PvpHandler(app);
 }
 
@@ -33,20 +33,20 @@ export class PvpHandler {
     constructor(private app: Application) {
     }
 
-    async addRoleScore(msg: {heroScores: Array<{hid: number, score:number}>}, session: BackendSession) {
+    async addRoleScore(msg: { heroScores: Array<{ hid: number, score: number }> }, session: BackendSession) {
         let { heroScores: addHeroScores } = msg;
         let roleId = session.get('roleId');
         let sid = session.get('sid');
         const funcs: number[] = session.get('funcs');
-        let {heroScores, hisScore} = await PvpDefenseModel.findByRoleId(roleId);
+        let { heroScores, hisScore } = await PvpDefenseModel.findByRoleId(roleId);
         let score = 0;
-        for (let {hid, score: heroScore} of addHeroScores) {
+        for (let { hid, score: heroScore } of addHeroScores) {
             if (heroScore < 0) continue;
-            let index = findIndex(heroScores, {hid});
+            let index = findIndex(heroScores, { hid });
             if (index != -1) {
                 heroScores[index].score = heroScore;
             } else {
-                heroScores.push({hid, score :heroScore});
+                heroScores.push({ hid, score: heroScore });
             }
         }
         for (let heroScore of heroScores) {
@@ -59,7 +59,7 @@ export class PvpHandler {
             hisScore = score;
         }
         let pLv = getPLvByScore(score);
-        let pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { score, hisScore, pLv, heroScores});
+        let pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { score, hisScore, pLv, heroScores });
         let roleName = session.get('roleName');
         const role = await RoleModel.findByRoleId(roleId);
 
@@ -70,27 +70,27 @@ export class PvpHandler {
         // 任务
         await checkTask(roleId, sid, funcs, TASK_TYPE.PVP_HERO_SCORE, 0, false, { heroScores });
 
-        return resResult(STATUS.SUCCESS, {score, hisScore, heroScores});
+        return resResult(STATUS.SUCCESS, { score, hisScore, heroScores });
     }
 
     async debugPvpSeasonReset(msg: {}, session: BackendSession) {
-        let { seasonNum, seasonEndTime } = await setPvpSeasonResult({name: 'exce setPvpSeasonResult debug'});
+        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});
+        return resResult(STATUS.SUCCESS, { systemConfig });
     }
 
-    async debugPvpSeasonResetTime(msg: {day: number}, session: BackendSession) {
-        let { day:hour } = msg;
+    async debugPvpSeasonResetTime(msg: { day: number }, session: BackendSession) {
+        let { day: hour } = msg;
         let { seasonNum, seasonEndTime } = await pinus.app.rpc.systimer.systimerRemote.resetPvpSeasonTime.toServer('systimer-server-1', hour);
         return resResult(STATUS.SUCCESS, { seasonNum, seasonEndTime });
     }
 
-    async debugAddChallengeCnt(msg: {challengeCnt: number}, session: BackendSession) {
-        let { challengeCnt } = msg; 
+    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;
@@ -99,64 +99,66 @@ export class PvpHandler {
         return resResult(STATUS.SUCCESS, { challengeCnt, challengeRefTime });
     }
 
-    async getData (msg: {}, session: BackendSession) {
+    async getData(msg: {}, session: BackendSession) {
         let roleId = session.get('roleId');
         let { pvpDefense, warId, seasonEndTime } = await findPvpDefAllByRoleId(roleId);
         let oppPlayers = await getEnemies(pvpDefense.oppPlayers, pvpDefense.winStreakNum);
         let { isDefaultHero, heroes, score, pLv, winStreakNum, refOppCnt, challengeCnt, challengeRefTime, receivedBox, hisScore, heroScores, isFirstEntry, seasonNum } = pvpDefense;
         if (isFirstEntry) {
-            await PvpDefenseModel.updateInfo(roleId, {isFirstEntry:false});
+            await PvpDefenseModel.updateInfo(roleId, { isFirstEntry: false });
         }
         let pvpSeasonResult = await PvpSeasonResultModel.getPvpSeasonResult(roleId);
         let flag = false;
         if (!!pvpSeasonResult) {
-            var { oldSeasonData, show, heroGoods, rankGoods} = pvpSeasonResult;
-            if ( oldSeasonData.seasonEndTime > nowSeconds()) {//结算中锁定玩家信息，结算结束后统一展示修改完成的信息
+            var { oldSeasonData, show, heroGoods, rankGoods } = pvpSeasonResult;
+            if (oldSeasonData.seasonEndTime > nowSeconds()) {//结算中锁定玩家信息，结算结束后统一展示修改完成的信息
                 seasonEndTime = oldSeasonData.seasonEndTime;
                 heroScores = oldSeasonData.heroScores;
                 score = oldSeasonData.score;
                 refOppCnt = oldSeasonData.refOppCnt;
-                challengeCnt = oldSeasonData.challengeCnt; 
-                challengeRefTime = oldSeasonData.challengeRefTime; 
+                challengeCnt = oldSeasonData.challengeCnt;
+                challengeRefTime = oldSeasonData.challengeRefTime;
             } else if (show) {//是否需要弹出结算奖励界面
-                await PvpSeasonResultModel.updatePvpSeasonResult(roleId, {show: false});
+                await PvpSeasonResultModel.updatePvpSeasonResult(roleId, { show: false });
                 flag = true;
             }
         }
 
         let r = new Rank(REDIS_KEY.PVP_RANK, {});
-        let myRank = await r.getMyRank({roleId});//去redis中获取排名
-        
-        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 }
+        let myRank = await r.getMyRank({ roleId });//去redis中获取排名
+
+        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
+        }
         if (flag) {//弹出结赛季结算奖励
-            data.resultRecord = { oldSeasonData, heroGoods, rankGoods } 
+            data.resultRecord = { oldSeasonData, heroGoods, rankGoods }
         }
         return resResult(STATUS.SUCCESS, data);
     }
 
     // 刷新对手
-    async refreshOppPlayer (msg: {}, session: BackendSession) {
+    async refreshOppPlayer(msg: {}, session: BackendSession) {
         let roleId = session.get('roleId');
         let sid = session.get('sid');
 
         let pvpDefense = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
- 
+
         // 刷新次数及消耗
         let { refOppCnt, refOppTime, consume } = getRefOppCnt(pvpDefense.refOppCnt, pvpDefense.refOppTime);
-        if(refOppCnt >= gameData.maxPvpRefreshCnt) {
+        if (refOppCnt >= gameData.maxPvpRefreshCnt) {
             return resResult(STATUS.PVP_REFRESH_CNT_REACH_MAX);
         }
 
         let costResult = await handleCost(roleId, sid, consume);
-        if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
+        if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
         // 刷新对手
         let role = <RoleType>pvpDefense.role;
         let oppPlayers = await refreshEnemies(role, pvpDefense.score, pvpDefense.pLv);
-        
+
         pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { oppPlayers, refOppCnt: refOppCnt + 1, refOppTime });
         let result = await getEnemies(pvpDefense.oppPlayers, pvpDefense.winStreakNum);
 
@@ -165,7 +167,7 @@ export class PvpHandler {
     }
 
     // 获取对手阵容具体信息
-    async getOppPlayer (msg: { roleId: string }, session: BackendSession) {
+    async getOppPlayer(msg: { roleId: string }, session: BackendSession) {
         let roleId = session.get('roleId');
 
         let oppoRoleId = msg.roleId;
@@ -173,29 +175,29 @@ export class PvpHandler {
         let { oppPlayers } = pvpDefense;
 
         let curOpp = oppPlayers.find(cur => cur.roleId == oppoRoleId);
-        if(!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND);
+        if (!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND);
 
-        let { oppRoleId, heroes } = <PvpHistoryOppType>curOpp.oppDef;        
+        let { oppRoleId, heroes } = <PvpHistoryOppType>curOpp.oppDef;
 
         return resResult(STATUS.SUCCESS, { roleId: oppRoleId, pos: curOpp.pos, heroes });
     }
 
     // 开战
-    async pvpStart (msg: { warId: number, heroes: number[], roleId: string }, session: BackendSession) {
+    async pvpStart(msg: { warId: number, heroes: number[], roleId: string }, session: BackendSession) {
         const { warId, heroes, roleId: oppRoleId } = msg;
         let roleId = session.get('roleId');
         let roleName = session.get('roleName');
 
         let warInfo = gameData.war.get(warId);
-        if(!warInfo) {
+        if (!warInfo) {
             return resResult(STATUS.BATTLE_MISS_INFO);
         }
 
         let { isOK } = await checkBattleHeroesByHid(roleId, heroes);
-        if(!isOK) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
+        if (!isOK) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
 
         const pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
-        if(!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
+        if (!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
         // 检查挑战次数
         let { seasonEndTime } = await SystemConfigModel.findSystemConfig();
         let { challengeCnt } = refresh(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
@@ -204,7 +206,7 @@ export class PvpHandler {
         }
         let { oppPlayers } = pvpDefense;
         let curOpp = oppPlayers.find(cur => cur.roleId == oppRoleId);
-        if(!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND)
+        if (!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND)
 
         const battleCode = genCode(8); // 关卡唯一值
 
@@ -224,44 +226,45 @@ export class PvpHandler {
     }
 
     // 结算
-    async pvpEnd (msg: { battleCode: string, isSuccess: boolean, myHeroes: pvpEndParamInter[],  oppHeroes: pvpEndParamInter[] }, session: BackendSession) {
+    async pvpEnd(msg: { battleCode: string, isSuccess: boolean, myHeroes: pvpEndParamInter[], oppHeroes: pvpEndParamInter[] }, session: BackendSession) {
 
         let roleId = session.get('roleId');
         let roleName = session.get('roleName');
         let sid = session.get('sid');
         const funcs: number[] = session.get('funcs');
+        const serverId = session.get('serverId');
 
         const { battleCode, isSuccess, myHeroes, oppHeroes } = msg;
-   
+
         const BattleRecord = await BattleRecordModel.getBattleRecordByCode(battleCode, true);
-        if(!BattleRecord || BattleRecord.status != 0) {
+        if (!BattleRecord || BattleRecord.status != 0) {
             return resResult(STATUS.BATTLE_STATUS_WRONG);
         }
 
         let { record: { heroes: dbHeroes, oppRoleId, pos } } = BattleRecord;
 
         let flag = 1; // 对比hero信息
-        for(let {hid} of myHeroes) {
-            if(dbHeroes.indexOf(hid) == -1) flag = 0;
+        for (let { hid } of myHeroes) {
+            if (dbHeroes.indexOf(hid) == -1) flag = 0;
         }
-        if(!flag) return resResult(STATUS.BATTLE_INFO_VALIDATE_ERR);
+        if (!flag) return resResult(STATUS.BATTLE_INFO_VALIDATE_ERR);
 
         // 更新军功
-        let  {pvpDefense, warId} = await findPvpDefByRoleId(roleId);
-        if(!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
+        let { pvpDefense, warId } = await findPvpDefByRoleId(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);
+        if (!curOpp) return resResult(STATUS.PVP_ROLE_NOT_FOUND);
 
         const role = await RoleModel.findByRoleId(roleId, null, true);
-        if(isSuccess) {
-            winStreakNum ++;
+        if (isSuccess) {
+            winStreakNum++;
         } else {
             winStreakNum = 0;
         }
 
         const myRecInfo = await generMyRecInfo(heroScores, winStreakNum, role, isSuccess, pos, myHeroes);
-      
+
         let { attackInfo, showHeroScores, addSumScore } = myRecInfo
 
         score += addSumScore;
@@ -270,23 +273,23 @@ export class PvpHandler {
         const defenseInfo = await generPVPOppRecInfo(isSuccess, curOpp, oppHeroes, role.lv);
 
         // 战报记录
-        await PvpRecordModel.createRec({roleId1: roleId, roleId2: robotIdComBack(oppRoleId), warId: BattleRecord.battleId, attackInfo, defenseInfo, createTime: nowSeconds()});
+        await PvpRecordModel.createRec({ roleId1: roleId, roleId2: robotIdComBack(oppRoleId), warId: BattleRecord.battleId, attackInfo, defenseInfo, createTime: nowSeconds() });
 
         // 对手记录更新
         await PvpHistoryOppModel.setStatus(roleId, oppRoleId, 1);
-        
+
         // 刷新对手
         let newOppPlayers: Array<OppPlayers> = await refreshEnemies(role, score, pLv);
 
         // 更新battleRecord
         await BattleRecordModel.updateBattleRecordByCode(battleCode, {
-            $set: { status: isSuccess?1:2 }
+            $set: { status: isSuccess ? 1 : 2 }
         }, true);
         let { seasonEndTime } = await SystemConfigModel.findSystemConfig();
 
         // 减少挑战次数
         let { challengeCnt, challengeRefTime } = comsumeChallengeCnt(pvpDefense.challengeCnt, pvpDefense.challengeRefTime, seasonEndTime);
-        if ( hisScore < score) {
+        if (hisScore < score) {
             hisScore = score;
         }
         pvpDefense = await PvpDefenseModel.updateInfoAndInclude(roleId, { oppPlayers: newOppPlayers, heroScores, score, pLv, winStreakNum, challengeCnt, challengeRefTime, hisScore });
@@ -295,10 +298,13 @@ export class PvpHandler {
         // 加入排行榜
         let r = new Rank(REDIS_KEY.PVP_RANK, {});
         await r.setRankWithRoleInfo(roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), role);
-        let myRank = await r.getMyRank({roleId});
+        let myRank = await r.getMyRank({ roleId });
 
         await checkTaskInPvpEnd(roleId, sid, funcs, isSuccess, heroScores);
-        
+        if (isSuccess) {
+            await checkActivityTask(serverId, sid, funcs, roleId, TASK_TYPE.PVP_WIN_SERIES, 1)
+        }
+
         return resResult(STATUS.SUCCESS, {
             battleCode, isSuccess,
             score, pLv, myRank, hisScore,
@@ -312,15 +318,15 @@ export class PvpHandler {
         });
     }
 
-    async saveDefense(msg: { heroes: Array<{actorId: number, dataId: number, order: number}>, isDefaultHero:boolean }, session: BackendSession) {
-        let {heroes, isDefaultHero} = msg;
+    async saveDefense(msg: { heroes: Array<{ actorId: number, dataId: number, order: number }>, isDefaultHero: boolean }, session: BackendSession) {
+        let { heroes, isDefaultHero } = 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; 
-        }); 
+        heroes = uniq(heroes, function (item) {
+            return item.order;
+        });
         let { seasonEndTime } = await SystemConfigModel.findSystemConfig();
         let { heroes: defHeros, challengeCnt: lastChallengeCnt, challengeRefTime: lastChallengeRefTime } = await PvpDefenseModel.findByRoleId(roleId);
         let defCe = 0;
@@ -333,26 +339,26 @@ export class PvpHandler {
             }).map(cur => cur.hid);
             let dataIds = new Array<number>(), orders = new Array<number>();
 
-            for(let hero of heroes) {
-                if(hero.actorId) {
+            for (let hero of heroes) {
+                if (hero.actorId) {
                     let isInTop = topLineup.find(cur => cur.hid == hero.actorId);
-                    if(!isInTop) {
+                    if (!isInTop) {
                         hero.actorId = hids.shift();
                     }
                     dataIds.push(hero.dataId);
                     orders.push(hero.order);
                 }
             }
-            for(let hid of hids) {
+            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;
+                    if (dataIds.includes(i)) continue;
                     dataIds.push(i);
                     dataId = i; break;
                 }
                 let order = 0;
                 for (let i = PVP_HERO_ORDER.START; i <= PVP_HERO_ORDER.END; i++) {
-                    if(orders.includes(i)) continue;
+                    if (orders.includes(i)) continue;
                     orders.push(i);
                     order = i; break;
                 }
@@ -363,11 +369,11 @@ export class PvpHandler {
         }
 
         for (let dataId = PVP_HERO_POS.START; dataId <= PVP_HERO_POS.END; dataId++) {
-            let index = findIndex(heroes, {dataId});
-            let defIndex = findIndex(defHeros, {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});
+                defHeros.push({ actorId: 0, order: 0, ce: 0, hero: null, dataId });
             }
             if (index == -1) {
                 defHeros[defIndex].actorId = 0;
@@ -383,16 +389,16 @@ export class PvpHandler {
             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; 
+            defCe += hero.ce;
         }
-        let { heroes: resHeroes } = await PvpDefenseModel.updateInfo(roleId, {defCe, heroes: defHeros, challengeCnt, challengeRefTime, isDefaultHero });
+        let { heroes: resHeroes } = await PvpDefenseModel.updateInfo(roleId, { defCe, heroes: defHeros, challengeCnt, challengeRefTime, isDefaultHero });
         return resResult(STATUS.SUCCESS, { heroes: resHeroes, challengeCnt, challengeRefTime, isDefaultHero });
-        
+
     }
 
     async getRank(msg: {}, session: BackendSession) {
@@ -400,11 +406,11 @@ export class PvpHandler {
         let roleId = session.get('roleId');
 
         let r = new Rank(REDIS_KEY.PVP_RANK, {});
-        let {ranks, myRank} = await r.getRankListWithMyRank({roleId});
+        let { ranks, myRank } = await r.getRankListWithMyRank({ roleId });
 
-        if(!myRank) {
+        if (!myRank) {
             let pvpDefense = await PvpDefenseModel.findByRoleId(roleId);
-            
+
             myRank = await r.generMyRankWithRole(roleId, pvpDefense.score, getSeconds(pvpDefense.refOppTime));
         }
 
@@ -417,52 +423,52 @@ export class PvpHandler {
 
         let { roleId: oppoRoleId } = msg;
         let isRobot = checkRoleIsRobot(oppoRoleId);
-        
+
         let result: PlayerDetail;
 
-        if(isRobot) { // 如果是机器人，从自己的pvpDefense中寻找
+        if (isRobot) { // 如果是机器人，从自己的pvpDefense中寻找
             let pvpHistoryOpp = await PvpHistoryOppModel.findByRoleIdAndOppId(roleId, oppoRoleId);
-            if(!pvpHistoryOpp) {
+            if (!pvpHistoryOpp) {
                 return resResult(STATUS.PVP_ROLE_NOT_FOUND);
             }
 
             let heroes = new Array<PlayerDetailHero>();
-            for(let hero of pvpHistoryOpp.heroes) {
+            for (let hero of pvpHistoryOpp.heroes) {
                 let newHero = new PlayerDetailHero();
                 newHero.setPvpHeroInfo(hero);
                 heroes.push(newHero);
             }
-            for(let hero of pvpHistoryOpp.otherHeroes) {
+            for (let hero of pvpHistoryOpp.otherHeroes) {
                 let newHero = new PlayerDetailHero();
                 newHero.setPvpHeroInfo(hero);
                 heroes.push(newHero);
             }
-            result = new PlayerDetail({...pvpHistoryOpp, roleId: pvpHistoryOpp.oppRoleId, heroes, rank: pvpHistoryOpp.rankLv});
+            result = new PlayerDetail({ ...pvpHistoryOpp, roleId: pvpHistoryOpp.oppRoleId, heroes, rank: pvpHistoryOpp.rankLv });
         } else { // 查询对方pvpDefense
             let pvpDefense = await PvpDefenseModel.findByRoleId(oppoRoleId);
             let dbHeroes = await HeroModel.findByRole(oppoRoleId);
             let role = await RoleModel.findByRoleId(oppoRoleId);
 
             let heroes = new Array<PlayerDetailHero>();
-            for(let {hid, lv, star, colorStar, quality } of dbHeroes) {
+            for (let { hid, lv, star, colorStar, quality } of dbHeroes) {
                 let heroScore = pvpDefense.heroScores.find(cur => cur.hid == hid);
                 heroes.push({
                     actorId: hid, lv, star, colorStar, quality,
-                    score: heroScore?heroScore.score: 0
+                    score: heroScore ? heroScore.score : 0
                 });
             }
             heroes.sort((a, b) => b.score - a.score);
             let r = new Rank(REDIS_KEY.PVP_RANK, {});
             let rank = await r.getMyRank({ roleId: oppoRoleId });//去redis中获取排名
 
-            result = new PlayerDetail({...role, ...pvpDefense, heroes, rank});
+            result = new PlayerDetail({ ...role, ...pvpDefense, heroes, rank });
         }
-        
+
         return resResult(STATUS.SUCCESS, result);
     }
 
-    async receiveBox(msg: {id: number}, session: BackendSession) {
-        let {id} = msg;
+    async receiveBox(msg: { id: number }, session: BackendSession) {
+        let { id } = msg;
         let roleId = session.get('roleId');
         let sid: string = session.get('sid');
         let roleName = session.get('roleName');
@@ -470,25 +476,25 @@ export class PvpHandler {
         let { seasonEndTime } = await SystemConfigModel.findSystemConfig();
         let { hisScore, receivedBox, challengeCnt: lastChallengeCnt, challengeRefTime: lastChallengeRefTime } = await PvpDefenseModel.findByRoleIdIncludeAll(roleId);
         let pvpBoxs = getPvpBoxs();
-        let pvpBox = findWhere(pvpBoxs, {id});
+        let pvpBox = findWhere(pvpBoxs, { id });
         if (hisScore < pvpBox.score) {
             return resResult(STATUS.PVP_NOT_REACH_BOX_SCORE);
         }
-        if (receivedBox.indexOf(id) != -1 ) {
+        if (receivedBox.indexOf(id) != -1) {
             return resResult(STATUS.PVP_BOX_IS_GOT);
         }
         receivedBox.push(id);
         let { challengeCnt, challengeRefTime } = refresh(lastChallengeCnt, lastChallengeRefTime, seasonEndTime);
-        await PvpDefenseModel.updateInfo(roleId, {receivedBox, challengeCnt, challengeRefTime});
-        let result = await addItems(roleId, roleName, sid, pvpBox.reward );
+        await PvpDefenseModel.updateInfo(roleId, { receivedBox, challengeCnt, challengeRefTime });
+        let result = await addItems(roleId, roleName, sid, pvpBox.reward);
         // 任务
         await checkTask(roleId, sid, funcs, TASK_TYPE.PVP_RECEIVE_BOX, 1, true, {});
-        return resResult(STATUS.SUCCESS,{goods: result,  receivedBox, challengeCnt, challengeRefTime});
+        return resResult(STATUS.SUCCESS, { goods: result, receivedBox, challengeCnt, challengeRefTime });
     }
-    
-    async getRec(msg: {}, session: BackendSession ) {
+
+    async getRec(msg: {}, session: BackendSession) {
         let roleId = session.get('roleId');
         let pvpRecords = await PvpRecordModel.getRecByRoleId(roleId);
-        return resResult(STATUS.SUCCESS, {list: pvpRecords});
+        return resResult(STATUS.SUCCESS, { list: pvpRecords });
     }
 }

game-server/app/servers/order/handler/orderHandler.ts

@@ -249,7 +249,7 @@ export class orderHandler {
             }), [{ uid: roleId, sid: sid }]);
             //活动统计
             await addRechargeMoney(roleId, serverId, price);
-            console.log(`测试支付完成!!!!!!!!!!!!!  serverId:${serverId}, productID:${productID}, roleId:${roleId}, localOrderID:${localOrderID}`)
+            console.log(`测试支付完成!!!!!!!!!!!!!  serverId:${serverId}, productID:${productID}, productType:${productType}, roleId:${roleId}, localOrderID:${localOrderID}, payType:${payType}`)
             return resResult(STATUS.SUCCESS, result);
         }
 

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

@@ -115,6 +115,7 @@ export class HeroHandler {
         let roleId: string = session.get('roleId');
         let sid: string = session.get('sid');
         let funcs: number[] = session.get('funcs');
+        const serverId = session.get('serverId');
 
         let { hid, type } = msg;
 
@@ -173,6 +174,7 @@ export class HeroHandler {
 
         // 任务
         await checkTaskWithHero(roleId, sid, funcs, TASK_TYPE.HERO_LV, hero, [oldLv]);
+        await checkActivityTask(serverId, sid, funcs, roleId, TASK_TYPE.HERO_LV, 1, { hid, lv: update.lv });
 
         const curHero = {
             hid, lv: hero.lv, exp: hero.exp
@@ -397,6 +399,7 @@ export class HeroHandler {
         await checkTask(roleId, sid, funcs, TASK_TYPE.HERO_TRAIN_SUM, 1, true, {});
         //活动统计
         await checkActivityTask(serverId, sid, funcs, roleId, TASK_TYPE.HERO_TRAIN_SUM, 1)
+        await checkActivityTask(serverId, sid, funcs, roleId, TASK_TYPE.HERO_TRAIN, 1, { hid })
 
         return resResult(STATUS.SUCCESS, { curHero: { hid: hero.hid, job: hero.job, jobStage: hero.jobStage } });
     }

game-server/app/services/growthFundService.ts

@@ -66,7 +66,7 @@ export async function getPlayerGrowthFundData(activityId: number, serverId: numb
                 for (let page of playerData.list) {
                     for (let item of page.items) {
                         if (item.taskType == TASK_TYPE.BATTLE_MAIN) {
-                            let index = warIDs.findIndex(id => { return id === item.condition })
+                            let index = warIDs.findIndex(id => { return id === item.taskParamArray[1] })
                             if (index != -1) {
                                 item.isComplete = true;
                             }

game-server/app/services/growthService.ts

@@ -2,6 +2,7 @@ import { ACTIVITY_TYPE } from '../consts';
 import { ActivityModel, ActivityModelType } from '../db/Activity';
 import { ActivityGrowthModel, ActivityGrowthModelType } from '../db/ActivityGrowth';
 import { ActivityGrowthPointModel, ActivityGrowthPointModelType } from '../db/ActivityGrowthPoint';
+import { HeroModel } from '../db/Hero';
 import { ServerlistModel } from '../db/Serverlist';
 import { GrowthData, GrowthItem } from '../domain/activityField/growthField';
 
@@ -23,8 +24,9 @@ export async function growthActivity(serverId: number, roleId: string) {
     let playerRecords: ActivityGrowthModelType[] = await ActivityGrowthModel.findData(serverId, activityData.activityId, roleId);
     let playerPointRecord: ActivityGrowthPointModelType = await ActivityGrowthPointModel.findData(serverId, activityData.activityId, roleId);
 
+    let userHeroes = await HeroModel.findByRole(roleId);
     let playerData = new GrowthData(activityData);
-    await playerData.setPlayerRecords(playerRecords, roleId);
+    await playerData.setPlayerRecords(playerRecords, roleId, userHeroes);
     playerData.setPlayerPointRecord(playerPointRecord);
     return playerData;
 }
@@ -42,8 +44,10 @@ export async function getPlayerGrowthData(activityId: number, serverId: number,
     let playerRecords: ActivityGrowthModelType[] = await ActivityGrowthModel.findData(serverId, activityId, roleId);
     let playerPointRecord: ActivityGrowthPointModelType = await ActivityGrowthPointModel.findData(serverId, activityId, roleId);
 
+    let userHeroes = await HeroModel.findByRole(roleId);
+
     let playerData = new GrowthData(activityData);
-    await playerData.setPlayerRecords(playerRecords, roleId);
+    await playerData.setPlayerRecords(playerRecords, roleId, userHeroes);
     playerData.setPlayerPointRecord(playerPointRecord);
     return playerData;
 }

game-server/app/services/taskService.ts

@@ -80,6 +80,7 @@ export async function checkActivityTask(serverId: number, sid: string, funcs: nu
 }
 
 export async function pushActivityUpdate(roleId: string, sid: string, funcs: number[], pushMessage: any[]) {
+    console.log('pushActivityUpdate', JSON.stringify(pushMessage))
     if (pushMessage.length > 0) {
         if (!sid || !funcs) {
             let onlineUser = await getRoleOnlineInfo(roleId);
@@ -109,6 +110,7 @@ export async function checkTaskInBattleEnd(serverId: number, roleId: string, sid
     await checkTaskWithWar(roleId, sid, funcs, TASK_TYPE.BATTLE_EXPEDITION, battleId, heroes, 1, star);
     //成长任务
     await checkActivityTask(serverId, sid, funcs, roleId, TASK_TYPE.BATTLE_MAIN, 1, { warId: battleId })
+    await checkActivityTask(serverId, sid, funcs, roleId, TASK_TYPE.BATTLE_EXPEDITION, 1)
 
 }