活动：添加新的任务统计

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) {
+    async debugPvpSeasonResetTime(msg: { day: number }, session: BackendSession) {
-        let { day:hour } = msg;
+        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) {
+    async debugAddChallengeCnt(msg: { challengeCnt: number }, session: BackendSession) {
-        let { challengeCnt } = msg; 
+        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;
+            var { oldSeasonData, show, heroGoods, rankGoods } = pvpSeasonResult;
-            if ( oldSeasonData.seasonEndTime > nowSeconds()) {//结算中锁定玩家信息，结算结束后统一展示修改完成的信息
+            if (oldSeasonData.seasonEndTime > nowSeconds()) {//结算中锁定玩家信息，结算结束后统一展示修改完成的信息
                 seasonEndTime = oldSeasonData.seasonEndTime;
                 heroScores = oldSeasonData.heroScores;
                 score = oldSeasonData.score;
                 refOppCnt = oldSeasonData.refOppCnt;
-                challengeCnt = oldSeasonData.challengeCnt; 
+                challengeCnt = oldSeasonData.challengeCnt;
-                challengeRefTime = oldSeasonData.challengeRefTime; 
+                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 myRank = await r.getMyRank({ roleId });//去redis中获取排名
-        
+
-        let data:any = {warId, seasonNum, seasonEndTime, myRank, oppPlayers, heroes: heroes.map(cur => {
+        let data: any = {
-            let {actorId, dataId, order} = cur;
+            warId, seasonNum, seasonEndTime, myRank, oppPlayers, heroes: heroes.map(cur => {
-            return { actorId, dataId, order }
+                let { actorId, dataId, order } = cur;
-        }), score, pLv, winStreakNum, refOppCnt, challengeCnt, challengeRefTime, receivedBox, hisScore, heroScores, isFirstEntry, isDefaultHero }
+                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) {
+        for (let { hid } of myHeroes) {
-            if(dbHeroes.indexOf(hid) == -1) flag = 0;
+            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);
+        let { pvpDefense, warId } = await findPvpDefByRoleId(roleId);
-        if(!pvpDefense) return resResult(STATUS.PVP_NOT_OPEN);
+        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) {
+        if (isSuccess) {
-            winStreakNum ++;
+            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) {
+    async saveDefense(msg: { heroes: Array<{ actorId: number, dataId: number, order: number }>, isDefaultHero: boolean }, session: BackendSession) {
-        let {heroes, isDefaultHero} = msg;
+        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) {
+        heroes = uniq(heroes, function (item) {
-            return item.order; 
+            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) {
+            for (let hero of heroes) {
-                if(hero.actorId) {
+                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 index = findIndex(heroes, { dataId });
-            let defIndex = findIndex(defHeros, {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) {
+    async receiveBox(msg: { id: number }, session: BackendSession) {
-        let {id} = msg;
+        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});
+        await PvpDefenseModel.updateInfo(roleId, { receivedBox, challengeCnt, challengeRefTime });
-        let result = await addItems(roleId, roleName, sid, pvpBox.reward );
+        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)
 
 }
 

shared/db/ActivityDailyChallenges.ts

@@ -23,6 +23,8 @@ export default class Activity_Daily_Challenges extends BaseModel {
     totalCount: number;				// 累计达成次数
     @prop({ required: true })
     receiveRewardCount: number;					// 领取奖励次数
+    @prop({ required: true })
+    data: string;					// 数据信息
 
     //任务领取记录
     public static async addCellRecord(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, count: number, lean = true) {
@@ -45,6 +47,14 @@ export default class Activity_Daily_Challenges extends BaseModel {
         return result;
     }
 
+    //根据活动记录统计数据
+    public static async addTaskRecord(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, data: string,) {
+        let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex, type },
+            { $set: { data: data } }, { upsert: true, new: true }).lean(true);
+        return result;
+    }
+
+
     //根据活动id查询活动数据
     public static async findData(serverId: number, activityId: number, roleId: string, lean = true) {
         let result: ActivityDailyChallengesModelType[] = await ActivityDailyChallengesModel.find({ serverId, roleId, activityId }).lean(lean);
@@ -58,8 +68,8 @@ export default class Activity_Daily_Challenges extends BaseModel {
     }
 
     //查询第几天某个的活动数据
-    public static async findDataByCellIndex(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, lean = true) {
+    public static async findDataByCellIndex(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number) {
-        let result: ActivityDailyChallengesModelType[] = await ActivityDailyChallengesModel.find({ serverId, roleId, activityId, dayIndex, cellIndex }).lean(lean);
+        let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOne({ serverId, roleId, activityId, dayIndex, cellIndex, type }).lean(true);
         return result;
     }
 

shared/db/ActivityGrowth.ts

@@ -1,5 +1,6 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
+import { TASK_TYPE } from '../consts';
 
 /**
   * 活动系统 - 成长任务活动
@@ -23,8 +24,8 @@ export default class Activity_Growth extends BaseModel {
     totalCount: number;				// 累计达成次数
     @prop({ required: true })
     receiveRewardCount: number;					// 领取奖励次数
-    @prop({ required: true, default: false })
+    @prop({ required: true })
-    getPointReward: boolean;					// 是否兑换领取奖章奖励
+    data: string;					// 数据信息
 
     //任务领取记录
     public static async addCellRecord(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, count: number,) {
@@ -33,13 +34,6 @@ export default class Activity_Growth extends BaseModel {
         return result;
     }
 
-    //当日奖章领取记录
-    public static async addDayRecord(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, lean = true) {
-        let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex },
-            { $set: { getPointReward: true } }, { upsert: true, new: true }).lean(lean);
-        return result;
-    }
-
     //根据活动统计完成任务次数
     public static async setTaskCount(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, count: number, lean = true) {
         let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex, type },
@@ -54,6 +48,14 @@ export default class Activity_Growth extends BaseModel {
         return result;
     }
 
+    //根据活动记录统计数据
+    public static async addTaskRecord(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, data: string,) {
+        let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex, type },
+            { $set: { data: data } }, { upsert: true, new: true }).lean(true);
+        return result;
+    }
+
+
     //根据活动id查询活动数据
     public static async findData(serverId: number, activityId: number, roleId: string, lean = true) {
         let result: ActivityGrowthModelType[] = await ActivityGrowthModel.find({ serverId, roleId, activityId }).lean(lean);

shared/db/ActivityThirtyDays.ts

@@ -23,6 +23,8 @@ export default class Activity_Thirty_Days extends BaseModel {
     totalCount: number;				// 累计达成次数
     @prop({ required: true })
     isReceive: boolean;				// 是否领取过奖励
+    @prop({ required: true })
+    data: string;					// 数据信息
 
     //添加领取记录
     public static async addRecord(serverId: number, activityId: number, roleId: string, pageIndex: number, cellIndex: number, lean = true) {
@@ -38,6 +40,13 @@ export default class Activity_Thirty_Days extends BaseModel {
         return result;
     }
 
+    //根据活动记录统计数据
+    public static async addTaskRecord(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, data: string,) {
+        let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex, type },
+            { $set: { data: data } }, { upsert: true, new: true }).lean(true);
+        return result;
+    }
+
     //根据活动统计完成任务次数
     public static async setTaskCount(serverId: number, activityId: number, roleId: string, pageIndex: number, cellIndex: number, type: number, count: number, lean = true) {
         let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOneAndUpdate({ serverId, roleId, activityId, pageIndex, cellIndex, type },

shared/domain/activityField/growthField.ts

@@ -2,10 +2,9 @@ import { TASK_TYPE, ACTIVITY_RESOURCES_TYPE } from '../../consts';
 import { ActivityModelType } from '../../db/Activity';
 import { ActivityGrowthModelType } from '../../db/ActivityGrowth';
 import { ActivityGrowthPointModelType } from '../../db/ActivityGrowthPoint';
+import { HeroType } from '../../db/Hero';
 import { RoleModel } from '../../db/Role';
-import { RewardInter } from '../../pubUtils/interface';
+import { splitString } from '../../pubUtils/util';
-import { parseGoodStrWithType, parseHeroStrWithType } from '../../pubUtils/util';
-import { CreateHeroParam } from '../roleField/hero';
 import { ActivityBase } from './activityField';
 
 
@@ -40,6 +39,7 @@ export class GrowthItem {
     condition: number;      //任务数据条件 dic_zyz_taskType.jsonT
     point: number;          // 任务达成获得的奖章数量，只在当前活动中有用，虚拟
     reward: string;         // 任务奖励，格式:1&3&1(类型&id&数量) 类型定义:1.英雄，2.物品
+    taskParamArray: number[];
 
     totalCount: number = 0; //完成任务累计次数
     receiveRewardCount: number = 0;          //领取奖励次数
@@ -55,26 +55,8 @@ export class GrowthItem {
         this.reward = data.reward;
         this.totalCount = 0;
         this.receiveRewardCount = 0;
-    }
+        this.taskParamArray = splitString(data.taskParam, '&')
 
-    public heroReward(): CreateHeroParam[] {
-        let rewardArray = [];
-        let rewardData = this.reward.split('|').filter(obj => { return obj && obj != '' });
-        for (let objStr of rewardData) {
-            let reward = parseHeroStrWithType(objStr);
-            rewardArray.push(reward);
-        }
-        return rewardArray.filter(obj => { return obj && obj.type == ACTIVITY_RESOURCES_TYPE.HERO })
-    }
-
-    public goodReward(): RewardInter[] {
-        let rewardArray = [];
-        let rewardData = this.reward.split('|').filter(obj => { return obj && obj != '' });
-        for (let objStr of rewardData) {
-            let reward = parseGoodStrWithType(objStr);
-            rewardArray.push(reward);
-        }
-        return rewardArray.filter(obj => { return obj && obj.type == ACTIVITY_RESOURCES_TYPE.GOODS })
     }
 
     public canReceive(): boolean {
@@ -146,7 +128,6 @@ export class GrowthData extends ActivityBase {
 
     //第几天的奖章兑换
     public findPointItem(id: number) {
-        console.log('ddddddddddd', JSON.stringify(this.pointRewardList), id)
         let index = this.pointRewardList.findIndex(obj => { return obj && obj.id === id })
         return (index != -1) ? this.pointRewardList[index] : null;
     }
@@ -162,7 +143,7 @@ export class GrowthData extends ActivityBase {
         })
     }
 
-    //解析玩家领取记录
+    //解析玩家积分兑换记录
     public setPlayerPointRecord(data: ActivityGrowthPointModelType) {
         if (!data) {
             return;
@@ -176,17 +157,21 @@ export class GrowthData extends ActivityBase {
     }
 
     //解析玩家领取记录
-    public async setPlayerRecords(data: ActivityGrowthModelType[], roleId: string) {
+    public async setPlayerRecords(data: ActivityGrowthModelType[], roleId: string, userHeroes: HeroType[]) {
         let { heroNum } = await RoleModel.findByRoleId(roleId);
         for (let obj of this.list) {
             let index = data.findIndex(record => { return obj.dayIndex == record.dayIndex && obj.cellIndex == record.cellIndex })
             if (index != -1) {
                 obj.totalCount = data[index].totalCount ? data[index].totalCount : 0;
-
                 obj.receiveRewardCount = data[index].receiveRewardCount ? data[index].receiveRewardCount : 0;
             }
             if (obj.taskType === TASK_TYPE.HERO_NUM) {
                 obj.totalCount = heroNum;
+            } else if (obj.taskType === TASK_TYPE.HERO_LV) {
+                obj.taskParam
+                let lv = obj.taskParamArray[1];
+                let heroes = userHeroes.filter(hero => { return hero.lv >= lv })
+                obj.totalCount = heroes.length;
             }
         }
     }

shared/domain/activityField/growthFundField.ts

@@ -2,6 +2,7 @@ import { ACTIVITY_RESOURCES_TYPE, ACTIVITY_TYPE } from '../../consts';
 import { ActivityModelType } from '../../db/Activity';
 import { ActivityBuyRecordsModelType } from '../../db/ActivityBuyRecords';
 import { ActivityGrowthFundModelType } from '../../db/ActivityGrowthFund';
+import { splitString } from '../../pubUtils/util';
 import { ActivityBase } from './activityField';
 
 
@@ -15,7 +16,7 @@ export class GrowthFundItem {
     condition: number;       //0
     reward: string;         // 任务奖励，格式:1&3&1(类型&id&数量) 类型定义:1.英雄，2.物品
     isComplete: boolean    //是否完成任务
-
+    taskParamArray: number[]//  
     // isReceive: boolean = false;          //是否领取过奖励
 
     constructor(data: any) {
@@ -28,6 +29,8 @@ export class GrowthFundItem {
         this.condition = data.conditon;
         this.isComplete = false;
         // this.isReceive = false;
+        this.taskParamArray = splitString(data.taskParam, '&')
+
     }
 }
 
@@ -70,14 +73,14 @@ export class GrowthFundData extends ActivityBase {
                 switch (this.type) {
                     case ACTIVITY_TYPE.GROWTH_FUND_MAIN:
                     case ACTIVITY_TYPE.GROWTH_FUND_MAIN_VIP: {
-                        if (!this.isReceive(page.pageIndex, item.cellIndex) && item.condition == condition) {
+                        if (!this.isReceive(page.pageIndex, item.cellIndex) && item.taskParamArray[1] == condition) {
                             item.isComplete = true;
                             items.push(Object.assign(item, { pageIndex: page.pageIndex, activityId: this.activityId }))
                         }
                         break;
                     }
-                    case ACTIVITY_TYPE.GROWTH_FUND_MAIN:
+                    case ACTIVITY_TYPE.GROWTH_FUND_TOWER:
-                    case ACTIVITY_TYPE.GROWTH_FUND_MAIN_VIP:
+                    case ACTIVITY_TYPE.GROWTH_FUND_TOWER_VIP:
                     case ACTIVITY_TYPE.GROWTH_FUND_MAIN_ELITE:
                     case ACTIVITY_TYPE.GROWTH_FUND_MAIN_ELITE_VIP: {
                         if (!this.isReceive(page.pageIndex, item.cellIndex) && item.condition <= condition) {

shared/pubUtils/itemUtils.ts

@@ -269,6 +269,7 @@ export async function createHeroes(roleId: string, roleName: string, serverId: n
     let taskPushMessage = m1.concat(m2, m3, m4);
     //成长任务
     await accomplishTask(serverId, roleId, TASK_TYPE.HERO_NUM, heroNum)
+    await accomplishTask(serverId, roleId, TASK_TYPE.HERO_QUALITY, heroNum, { heroes })
     return { role, figureInfo, heroes, calHeroResults, calAllHeroResults, taskPushMessage }
 }
 

shared/pubUtils/taskUtil.ts

@@ -494,7 +494,9 @@ export async function accomplishTask(serverId: number, roleId: string, taskType:
         let growthActivity = new GrowthData(activity);
         let taskArray = growthActivity.findTaskByType(taskType);
         for (let task of taskArray) {
-            let addCount = isComplete(roleId, task.taskType, task.taskParam, count, parma);
+            let taskRecord = await ActivityDailyChallengesModel.findDataByCellIndex(serverId, growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType)
+            let recordData = taskRecord && taskRecord.data ? JSON.parse(taskRecord.data) : null;
+            let { addCount, record } = isComplete(roleId, task.taskType, task.taskParam, count, parma, recordData);
             if (addCount) {
                 if (taskType == TASK_TYPE.ROLE_LV || taskType == TASK_TYPE.ROLE_TITLE) {
                     await ActivityGrowthModel.setTaskCount(serverId, growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType, addCount);
@@ -502,6 +504,9 @@ export async function accomplishTask(serverId: number, roleId: string, taskType:
                     await ActivityGrowthModel.addTaskCount(serverId, growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType, addCount);
                 }
             }
+            if (record) {
+                await ActivityGrowthModel.addTaskRecord(serverId, growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType, JSON.stringify(record));
+            }
         }
     }
 
@@ -511,7 +516,9 @@ export async function accomplishTask(serverId: number, roleId: string, taskType:
         let growthActivity = new DailyChallengesData(activity);
         let taskArray = growthActivity.findTaskByType(taskType, growthActivity.today());
         for (let task of taskArray) {
-            let addCount = isComplete(roleId, task.taskType, task.taskParam, count, parma);
+            let taskRecord = await ActivityDailyChallengesModel.findDataByCellIndex(serverId, growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType)
+            let recordData = taskRecord && taskRecord.data ? taskRecord.data : {}
+            let { addCount, record } = isComplete(roleId, task.taskType, task.taskParam, count, parma, recordData);
             if (addCount) {
                 if (taskType == TASK_TYPE.ROLE_LV || taskType == TASK_TYPE.ROLE_TITLE) {
                     await ActivityDailyChallengesModel.setTaskCount(serverId, growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType, addCount);
@@ -519,6 +526,9 @@ export async function accomplishTask(serverId: number, roleId: string, taskType:
                     await ActivityDailyChallengesModel.addTaskCount(serverId, growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType, addCount);
                 }
             }
+            if (record) {
+                await ActivityGrowthModel.addTaskRecord(serverId, growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType, JSON.stringify(record));
+            }
         }
     }
 
@@ -543,10 +553,15 @@ export async function accomplishTask(serverId: number, roleId: string, taskType:
             thirtyDaysActivity.setPlayerRecords(playerRecords);
             let taskArray = thirtyDaysActivity.findUncompleteTaskByType(taskType);
             for (let task of taskArray) {
-                let addCount = isComplete(roleId, task.taskType, task.taskParam, count, parma);
+                let taskRecord = await ActivityDailyChallengesModel.findDataByCellIndex(serverId, thirtyDaysActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType)
+                let recordData = taskRecord && taskRecord.data ? taskRecord.data : {}
+                let { addCount, record } = isComplete(roleId, task.taskType, task.taskParam, count, parma, recordData);
                 if (addCount) {
                     await ActivityThirtyDaysModel.addTaskCount(serverId, thirtyDaysActivity.activityId, roleId, task.pageIndex, task.cellIndex, task.taskType, addCount);
                 }
+                if (record) {
+                    await ActivityGrowthModel.addTaskRecord(serverId, thirtyDaysActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType, JSON.stringify(record));
+                }
             }
         }
     }
@@ -614,10 +629,11 @@ export async function accomplishTask(serverId: number, roleId: string, taskType:
    *
    */
 
-export function isComplete(roleId: string, taskType: TASK_TYPE, taskParam: string, count: number, paramObj?: any): number {
+export function isComplete(roleId: string, taskType: TASK_TYPE, taskParam: string, count: number, paramObj?: any, recordData?: any): any {
     console.log('达成任务标准', roleId, taskType, taskParam, count, paramObj)
     let param = splitString(taskParam, '&');
     let addCount: number = 0; // 条件是否满足
+    let record: any = null;
     switch (taskType) {
         case TASK_TYPE.ROLE_LV://重置数据
             addCount = count;
@@ -693,18 +709,79 @@ export function isComplete(roleId: string, taskType: TASK_TYPE, taskParam: strin
         case TASK_TYPE.GUILD_ACTIVITY:
             addCount = count;
             break;
-        case TASK_TYPE.HERO_TRAIN_SUM:
-            addCount = count;
-            break;
         case TASK_TYPE.EQUIP_SUM:
             addCount = count;
             break;
+        case TASK_TYPE.HERO_LV://{ hid, lv}
+            {
+                let hid = paramObj.hid;
+                let lv = paramObj.lv;
+                if (lv < param[1]) {
+                    break;
+                }
+                if (recordData) {
+                    if (recordData.indexOf(hid) != -1) {
+                        break;
+                    }
+                    record = recordData;
+                } else {
+                    record = [];
+                }
+
+                addCount = count;
+                record.push(hid)
+                break;
+            }
+        case TASK_TYPE.HERO_TRAIN_SUM://训练X次是所有武将的训练次数的总和达到要求就好了
+            {
+                addCount = count;
+                break;
+            }
+        case TASK_TYPE.HERO_TRAIN://X名武将训练Y次，要求单名武将训练Y次，这样的武将要有X名
+            {
+                let hid = paramObj.hid;
+                if (recordData) {
+                    record = recordData;
+                    if (record['hid']) {
+                        if (record['hid'] < param[1] && (record['hid'] + count >= param[1])) {
+                            addCount = count;
+                            record['hid'] += count;
+                            break;
+                        }
+                    }
+                }
+                record['hid'] = count;
+                break;
+            }
+        case TASK_TYPE.BATTLE_EXPEDITION:
+            {
+                addCount = count;
+                break;
+            }
+        case TASK_TYPE.BATTLE_EXPEDITION_BOX:
+            {
+                addCount = count;
+                break;
+            }
+        case TASK_TYPE.HERO_QUALITY:
+            {
+                let quality = param[1]
+                let heroes = paramObj.heroes.filter(hero => { return hero.quality == quality })
+                addCount = heroes.length;
+                break;
+            }
+        case TASK_TYPE.PVP_WIN_SERIES:
+            {
+                addCount = count;
+                break;
+            }
+
         default:
             addCount = 0;
             break;
 
     }
-    return addCount;
+    return { addCount, record };
 }
 
 /**