活动：添加新的任务统计

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

@@ -23,7 +23,7 @@ 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) {
     return new PvpHandler(app);
@@ -127,10 +127,12 @@ export class PvpHandler {
         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 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 }
+            }), score, pLv, winStreakNum, refOppCnt, challengeCnt, challengeRefTime, receivedBox, hisScore, heroScores, isFirstEntry, isDefaultHero
+        }
         if (flag) {//弹出结赛季结算奖励
             data.resultRecord = { oldSeasonData, heroGoods, rankGoods }
         }
@@ -230,6 +232,7 @@ export class PvpHandler {
         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;
 
@@ -298,6 +301,9 @@ export class PvpHandler {
         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,

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 };
 }
 
 /**