任务：修改taskType

game-server/app/servers/activity/handler/activityHandler.ts

@@ -77,7 +77,7 @@ export class ActivityHandler {
         // await checkActivityTask(serverId, sid, roleId, TASK_TYPE.PVP, 1)
 
         // await checkActivityTask(serverId, sid, roleId, TASK_TYPE.BATTLE_TOWER_LV, 1, { towerLv: lv })
-        // await checkActivityTask(serverId, sid, roleId, TASK_TYPE.GASHA, 1)
+        // await checkActivityTask(serverId, sid, roleId, TASK_TYPE.GACHA, 1)
 
         // if (lv == 2) {
         //     await GTCreateListMessage('批量推送测试11', 259200000, '哈哈哈哈哈11', '噢噢噢噢噢噢噢噢11')

game-server/app/servers/activity/handler/gachaHandler.ts

@@ -10,10 +10,9 @@ import { HeroModel } from "../../../db/Hero";
 import { handleCost, createHeroes, addItems } from "../../../services/role/rewardService";
 import { getZeroPointD, getTimeFun } from "../../../pubUtils/timeUtil";
 import { UserGachaRecModel } from "../../../db/UserGachaRec";
-import { ActivityModel } from "../../../db/Activity";
-import { checkActivityTask, checkTask } from "../../../services/task/taskService";
 import { RECRUIT } from "../../../pubUtils/dicParam";
 import { getActivityById } from "../../../services/activity/activityService";
+import { checkTaskInGacha } from "../../../services/task/taskService";
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -98,16 +97,7 @@ export class GachaHandler {
         });
 
         await UserGachaRecModel.createRec(roleId, gachaId, activityId, count, resultList);
-
+        await checkTaskInGacha(serverId, roleId, sid, count, resultHeroes);
-        // 任务
-        await checkTask(roleId, sid, TASK_TYPE.GASHA, count, true, {});
-        //活动统计
-        await checkActivityTask(serverId, sid, roleId, TASK_TYPE.GASHA, count)
-        for (let hero of resultHeroes) {
-            activityData.push({ hid: hero.hid, quality: hero.quality });
-        }
-        await checkActivityTask(serverId, sid, roleId, TASK_TYPE.GACHA_QUALITY_COUNT, count, { heroes: activityData })
-
         return resResult(STATUS.SUCCESS, {
             gachaId, activityId,
             freeCount, refFreeTime: userGacha.refFreeTime, count: userGacha.count, point: userGacha.point, floor, hope,
@@ -470,13 +460,7 @@ export class GachaHandler {
         await UserGachaRecModel.createRec(roleId, gachaId, 0, count, resultList);
 
         // 任务
-        await checkTask(roleId, sid, TASK_TYPE.GASHA, count, true, {});
+        await checkTaskInGacha(serverId, roleId, sid, count, resultHeroes);
-        //活动统计
-        await checkActivityTask(serverId, sid, roleId, TASK_TYPE.GASHA, count)
-        for (let hero of resultHeroes) {
-            activityData.push({ hid: hero.hid, quality: hero.quality });
-        }
-        await checkActivityTask(serverId, sid, roleId, TASK_TYPE.GACHA_QUALITY_COUNT, count, { heroes: activityData })
 
         return resResult(STATUS.SUCCESS, {
             hasInit: !!role.gachaHasGuide,

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

@@ -692,10 +692,7 @@ export class ComBattleHandler {
         }
 
         // 任务
-        await checkTaskWithArgs(roleId, sid, TASK_TYPE.CHAT, [getChannelType(CHANNEL_PREFIX.TEAM)]);
+        await checkTaskWithArgs(serverId, roleId, sid, TASK_TYPE.CHAT, { chatType: getChannelType(CHANNEL_PREFIX.TEAM) });
-
-        //活动任务
-        await checkActivityTask(serverId, sid, roleId, TASK_TYPE.CHAT, 1, { chatType: getChannelType(CHANNEL_PREFIX.TEAM) })
         return resResult(STATUS.SUCCESS);
     }
 

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

@@ -10,7 +10,7 @@ import { PvpDefenseModel, pvpUpdateInter } from '../../../db/PvpDefense';
 import { PvpSeasonResultModel } from '../../../db/PvpSeasonResult';
 import { PVPConfigModel } from '../../../db/SystemConfig';
 import { Rank } from '../../../services/rankService';
-import { checkActivityTask, checkTask, checkTaskInPvpEnd } from '../../../services/task/taskService';
+import { checkTask, checkTaskInPvpEnd } from '../../../services/task/taskService';
 import { Attack, AttackHero, Defense, DefenseHero, PvpDataReturn } from '../../../domain/battleField/pvp';
 import { DEBUG_MAGIC_WORD, FIGURE_UNLOCK_CONDITION, ITEM_CHANGE_REASON, LINEUP_NUM, REDIS_KEY, TASK_TYPE } from '../../../consts';
 import { PVP } from '../../../pubUtils/dicParam';
@@ -149,6 +149,7 @@ export class PvpHandler {
         const { warId, roleId: oppRoleId } = msg;
         let roleId = session.get('roleId');
         let roleName = session.get('roleName');
+        let serverId = session.get('serverId');
         let sid = session.get('sid');
 
         let warInfo = gameData.war.get(warId);
@@ -180,7 +181,7 @@ export class PvpHandler {
                 record: { heroes, pos: curOpp.pos, oppRoleId }
             }
         }, true);    
-        await checkTask(roleId, sid, TASK_TYPE.PVP, 1, true, {});
+        await checkTask(serverId, roleId, sid, TASK_TYPE.PVP);
 
         // 对手记录更新
         await PvpHistoryOppModel.setStatus(roleId, oppRoleId, 1);
@@ -276,12 +277,7 @@ export class PvpHandler {
         let myRank = await r.getMyRank({ roleId });
         result.setMyRank(myRank);
 
-        await checkTaskInPvpEnd(roleId, sid, isSuccess, pvpDefense.heroScores);
+        await checkTaskInPvpEnd(serverId, roleId, sid, isSuccess, pvpDefense.heroScores);
-        await checkActivityTask(serverId, sid, roleId, TASK_TYPE.PVP, 1)
-        if (isSuccess) {
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.PVP_WIN, 1)
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.PVP_WIN_SERIES, 1)
-        }
         if(hisWinStreakNum < pvpDefense.hisWinStreakNum) {
             await unlockFigure(sid, roleId, [{ type: FIGURE_UNLOCK_CONDITION.PVP_WIN_SERIES, paramWinStreakNum: pvpDefense.hisWinStreakNum }]);
         }
@@ -519,6 +515,7 @@ export class PvpHandler {
         let { id } = msg;
         let roleId = session.get('roleId');
         let sid: string = session.get('sid');
+        let serverId = session.get('serverId');
         let roleName = session.get('roleName');
         
         let seasonEndTime: number = this.app.get('pvpSeasonEndTime');
@@ -536,7 +533,7 @@ export class PvpHandler {
         await PvpDefenseModel.updateInfo(roleId, { receivedBox, challengeCnt, challengeRefTime });
         let result = await addItems(roleId, roleName, sid, pvpBox.reward, ITEM_CHANGE_REASON.PVP_BOX_REWARD);
         // 任务
-        await checkTask(roleId, sid, TASK_TYPE.PVP_RECEIVE_BOX, 1, true, {});
+        await checkTask(serverId, roleId, sid, TASK_TYPE.PVP_RECEIVE_BOX);
         return resResult(STATUS.SUCCESS, { goods: result, receivedBox, challengeCnt, challengeRefTime });
     }
 
@@ -554,6 +551,7 @@ export class PvpHandler {
         let { heroScores: addHeroScores } = msg;
         let roleId = session.get('roleId');
         let sid = session.get('sid');
+        let serverId = session.get('serverId');
         
         let { heroScores, hisScore } = await PvpDefenseModel.findByRoleId(roleId);
         let score = 0;
@@ -584,7 +582,7 @@ export class PvpHandler {
         await r.setRankWithRoleInfo(roleId, pvpDefense.score, pvpDefense.updatedAt.getTime(), role);
 
         // 任务
-        await checkTask(roleId, sid, TASK_TYPE.PVP_HERO_SCORE, 0, false, { heroScores });
+        await checkTask(serverId, roleId, sid, TASK_TYPE.PVP_HERO_SCORE, { heroScores });
 
         return resResult(STATUS.SUCCESS, { score, hisScore, heroScores });
     }

game-server/app/servers/connector/handler/entryHandler.ts

@@ -7,16 +7,13 @@ import { FrontendSession } from 'pinus';
 import { HeroModel } from './../../../db/Hero';
 import { genCode, generateStr, resResult } from '../../../pubUtils/util';
 import { COM_BTL_QUALITY, HERO_SELECT, DEBUG_MAGIC_WORD, REDIS_KEY, TASK_TYPE, ENTERY_ROLE_PICK, COUNTER, DEFAULT_LV, TA_USERSET_TYPE, LOG_TYPE } from '../../../consts';
-import { getAp } from '../../../services/actionPointService';
-import { ItemModel } from '../../../db/Item';
-import { SkinModel } from '../../../db/Skin';
 // import { loginRefresh } from '../../../services/playerEventService';
 import { nowSeconds, getZeroPoint } from '../../../pubUtils/timeUtil';
 import { rmRoleFromQueue, roleLeave, getRoleOnlineInfo, roleLogin } from '../../../services/redisService';
 
 import { addRoleToGuildChannel, addRoleToSysChannel, addRoleToWorldChannel, leaveGuildAuctionChannel, leaveGuildChannel, leaveSysChannel, leaveWorldAuctionChannel, leaveWorldChannel, recentGuildMsgs, recentPrivateChatInfos, recentSysMsgs, recentWorldMsgs } from '../../../services/chatService';
 import { reportOneOnline, savePlayTime } from '../../../services/authenticateService';
-import { checkTaskWithRole, } from '../../../services/task/taskService';
+import { checkTaskInEntry, } from '../../../services/task/taskService';
 import { pushData, everydayRefresh, kickUser } from '../../../services/connectorService';
 // import { setComBtlOnUserLeave } from '../../../services/comBattleService';
 import Counter from '../../../db/Counter';
@@ -65,7 +62,7 @@ export class EntryHandler {
             }
         }
         let serverName = this.app.getServerId();
-        await roleLogin(role.roleId, user.userCode, serverName, user.pkgName); // 保存在线用户
+        await roleLogin(role.roleId, user.userCode, serverName, user.pkgName, role.createTime); // 保存在线用户
         await this.addSession(role, session);
         saveLoginAndOutLog(LOG_TYPE.LOGIN, session);
 
@@ -75,9 +72,7 @@ export class EntryHandler {
         reportOneOnline(role.roleId, user.userCode, self.app.get('serverId'), true, user);
 
         // 任务
-        checkTaskWithRole(serverId, role.roleId, self.app.get('serverId'), TASK_TYPE.LOGIN_SUM, role);
+        checkTaskInEntry(serverId, role.roleId, self.app.get('serverId'), role);
-        checkTaskWithRole(serverId, role.roleId, self.app.get('serverId'), TASK_TYPE.LOGIN_SERIES, role);
-
         if (role.hasGuild) {
             addRoleToGuildChannel(role.roleId, self.app.get('serverId'), role.guildCode);
         }
@@ -154,8 +149,7 @@ export class EntryHandler {
 
         let { serverId } = role;
         // 任务
-        checkTaskWithRole(serverId, role.roleId, self.app.get('serverId'), TASK_TYPE.LOGIN_SUM, role);
+        checkTaskInEntry(serverId, role.roleId, self.app.get('serverId'), role);
-        checkTaskWithRole(serverId, role.roleId, self.app.get('serverId'), TASK_TYPE.LOGIN_SERIES, role);
         // 推送数据
         pushData(role.hasInit, role, session, 'refresh');
 

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

@@ -13,7 +13,7 @@ import { getDropItems, FIGURE_UNLOCK_CONDITION } from '../../../consts/constModu
 import { pushComposeOrangeHero, pushHeroQualityUpMsg, pushHeroStarMax, pushHeroWakeUp } from '../../../services/chatService';
 import { calculatetopLineup } from '../../../pubUtils/playerCe';
 import { PvpDefenseModel } from '../../../db/PvpDefense';
-import { checkTaskWithHero, checkTask, checkActivityTask } from '../../../services/task/taskService';
+import { checkTask, checkTaskInHeroQUalityUp, checkTaskInHeroStarUp, checkTaskInHeroTrain, checkTaskInHeroWakeUp } from '../../../services/task/taskService';
 import { isNumber, pick } from 'underscore';
 import { updateEplaces } from '../../../services/equipService';
 import { addConsumeToHero } from '../../../services/roleService';
@@ -128,8 +128,7 @@ export class HeroHandler {
         hero = await calPlayerCeAndSave(HERO_SYSTEM_TYPE.LVUP, sid, roleId, hero, update);
 
         // 任务
-        await checkTaskWithHero(roleId, sid, TASK_TYPE.HERO_LV, hero, [oldLv]);
+        await checkTask(serverId, roleId, sid, TASK_TYPE.HERO_LV, { oldLv, hero });
-        await checkActivityTask(serverId, sid, roleId, TASK_TYPE.HERO_LV, 1, { hid, lv: update.lv });
 
         const curHero = {
             hid, lv: hero.lv, exp: hero.exp
@@ -194,12 +193,7 @@ export class HeroHandler {
         if (isUpStar) {
             await calAllHeroCe(HERO_SYSTEM_TYPE.STAR, sid, roleId, {}, [hid, isUpStar ? 1 : 0]); // 升星可能影响到百家学院全局加成
             // 任务
-            await checkTaskWithHero(roleId, sid, TASK_TYPE.HERO_STAR_UP, hero);
+            await checkTaskInHeroStarUp(serverId, roleId, sid, hero, oldStar);
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.HERO_STAR_UP, 1);
-            await checkTaskWithHero(roleId, sid, TASK_TYPE.HERO_QUALITY_STAR_UP, hero);
-            //成长任务
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.HERO_QUALITY_STAR_UP, 1, { quality: dicHero.quality, star: hero.star });
-
         }
 
         const curHero = {
@@ -254,11 +248,7 @@ export class HeroHandler {
         }
         hero = await calPlayerCeAndSave(HERO_SYSTEM_TYPE.QUALITY, sid, roleId, hero, update);
         await calAllHeroCe(HERO_SYSTEM_TYPE.QUALITY, sid, roleId, {}, [hid, 0]); // 升品可能影响到百家学院全局加成
-
+        await checkTaskInHeroQUalityUp(serverId, roleId, sid, hero);
-        // 任务
-        await checkTaskWithHero(roleId, sid, TASK_TYPE.HERO_QUALITY_UP, hero);
-        // 任务
-        await checkActivityTask(serverId, sid, roleId, TASK_TYPE.HERO_QUALITY_TO_QUALITY_COUNT, 1, { oldQuality: dicHero.quality, quality: hero.quality });
 
         const curHero = {
             hid,
@@ -330,14 +320,10 @@ export class HeroHandler {
         hero = await calPlayerCeAndSave(HERO_SYSTEM_TYPE.COLORSTAR, sid, roleId, hero, update);
         if (isUpStar) {
             await calAllHeroCe(HERO_SYSTEM_TYPE.COLORSTAR, sid, roleId, {}, [hid, isUpStar ? 1 : 0]); // 升星可能影响到百家学院全局加成
-            ;
+            
             // 任务
-            await checkTaskWithHero(roleId, sid, TASK_TYPE.HERO_STAR_UP, hero);
+            await checkTaskInHeroWakeUp(serverId, roleId, sid, hero, oldColorStar);
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.HERO_STAR_UP, 1);
+            
-            await checkTask(roleId, sid, TASK_TYPE.HERO_WAKE_UP, 1, true, {});
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.HERO_QUALITY_WAKE_UP_COUNT, 1, { quality: hero.quality });
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.HERO_WAKE_UP_COUNT, 1, { hid: hid });
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.HERO_WAKE_UP_STAR_UP_COUNT, 1, { quality: dicHero.quality, colorStar: update.colorStar });
         }
         const curHero = {
             hid,
@@ -373,6 +359,7 @@ export class HeroHandler {
         let newJobStage = hero.jobStage;
         let oldJobStage = hero.jobStage, oldJob = hero.job;
         let max = isOneClick ? dicJob.maxStage: hero.jobStage + 1;
+        let trainCount = 0;
         let check = new CheckMeterial(roleId);
         for(let i = hero.jobStage; i < max; i++) {
             let singleConsume = dicJob.trainingConsume[i];
@@ -381,6 +368,7 @@ export class HeroHandler {
             let isEnough = await check.decrease([singleConsume]);
             if(!isEnough) break; // 消耗不足
             newJobStage ++;
+            trainCount++;
         }
         if (newJobStage == hero.jobStage) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
         let consumes = check.getConsume();
@@ -395,11 +383,7 @@ export class HeroHandler {
         }
         hero = await calPlayerCeAndSave(HERO_SYSTEM_TYPE.TRAIN, sid, roleId, hero, update);
         // 任务
-        await checkTaskWithHero(roleId, sid, TASK_TYPE.HERO_TRAIN, hero, [oldJob, oldJobStage]);
+        await checkTaskInHeroTrain(serverId, roleId, sid, hero, trainCount);
-        await checkTask(roleId, sid, TASK_TYPE.HERO_TRAIN_SUM, newJobStage - oldJobStage, true, {});
-        //活动统计
-        await checkActivityTask(serverId, sid, roleId, TASK_TYPE.HERO_TRAIN_SUM, newJobStage - oldJobStage);
-        await checkActivityTask(serverId, sid, roleId, TASK_TYPE.HERO_TRAIN, newJobStage - oldJobStage, { hid })
 
         return resResult(STATUS.SUCCESS, { curHero: { hid: hero.hid, job: hero.job, jobStage: hero.jobStage } });
     }
@@ -436,8 +420,7 @@ export class HeroHandler {
         }
         hero = await calPlayerCeAndSave(HERO_SYSTEM_TYPE.STAGEUP, sid, roleId, hero, update);
         // 任务
-        await checkTaskWithHero(roleId, sid, TASK_TYPE.HERO_STAGE_UP, hero);
+        await checkTask(serverId, roleId, sid, TASK_TYPE.HERO_STAGE_UP, { hero, stageUpCnt: 1 })
-        await checkActivityTask(serverId, sid, roleId, TASK_TYPE.HERO_STAGE_UP, 1, { job: hero.job });
 
         return resResult(STATUS.SUCCESS, { curHero: { hid: hero.hid, job: hero.job, jobStage: hero.jobStage } });
     }
@@ -446,6 +429,7 @@ export class HeroHandler {
     async heroConectionActivate(msg: { shipId: number }, session: BackendSession) {
         let roleId: string = session.get('roleId');
         let sid: string = session.get('sid');
+        let serverId: number = session.get('serverId');
         
         let { shipId } = msg;
         let shipHidAndLevel = gameData.friendShipHidAandIds.get(shipId);
@@ -493,7 +477,7 @@ export class HeroHandler {
         hero = await calPlayerCeAndSave(HERO_SYSTEM_TYPE.CONNECT, sid, roleId, hero, update, [shipId]);
 
         // 任务
-        await checkTask(roleId, sid, TASK_TYPE.HERO_CONNECT, 1, true, { connectLv: level })
+        await checkTask(serverId, roleId, sid, TASK_TYPE.HERO_CONNECT, { connectLv: level })
         return resResult(STATUS.SUCCESS, { curHero: { hid: hero.hid, connections: hero.connections } });
     }
 
@@ -573,8 +557,7 @@ export class HeroHandler {
             hero = await calPlayerCeAndSave(HERO_SYSTEM_TYPE.FAVOUR, sid, roleId, hero, update, [oldLv]);
 
             // 任务
-            await checkTaskWithHero(roleId, sid, TASK_TYPE.HERO_FAVOUR_LV, hero, [oldLv]);
+            await checkTask(serverId, roleId, sid, TASK_TYPE.HERO_FAVOUR_LV, { hero, oldFavourLv: oldLv });
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.HERO_FAVOUR_LV, 1, { lv: newLv, oldLv });
         } else {
             hero = await HeroModel.updateHeroInfo(roleId, hero.hid, update);
         }

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

@@ -16,7 +16,7 @@ import { HERO_SYSTEM_TYPE, LINEUP_NUM, ROLE_SELECT, REDIS_KEY, TASK_TYPE, DEFAUL
 import { checkBattleHeroesByHid, roleLevelup } from '../../../services/normalBattleService';
 import { Rank } from '../../../services/rankService';
 import { updateUserInfo } from '../../../services/redisService';
-import { checkTaskWithHero, checkTask, checkTaskWithArgs, checkActivityTask } from '../../../services/task/taskService';
+import { checkTask, checkTaskWithArgs, checkActivityTask } from '../../../services/task/taskService';
 import { getGoldObject, getCoinObject } from '../../../pubUtils/itemUtils';
 import { RScriptRecordModel } from '../../../db/RScriptRecord';
 import { SkinModel, SkinUpdate } from '../../../db/Skin';
@@ -61,7 +61,6 @@ export class RoleHandler {
             infos.set(heroInfo.hid, { heroInfo, skinInfo });
         }
         await createHero.createWithInitInfo(infos, initInfos.figureInfo);
-        await createHero.clearTask(await getActivities());
         await createHero.pushMessage(sid);
         await createHero.updateRedisRank();
         let heroes = createHero.getResultHeroes();

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

@@ -228,7 +228,7 @@ export class ShopHandler {
             tasks.push(task);
         }
         let task = getRandSingleEelm(tasks);
-        await checkTask(roleId, sid, task.taskType, task.condition, false, { isDebug: true });
+        // await checkTask(roleId, sid, task.taskType, task.condition, false, { isDebug: true });
         return resResult(STATUS.SUCCESS, {
             task
         });
@@ -332,9 +332,6 @@ export class ShopHandler {
         let sid = session.get('sid');
         let role = await RoleModel.findByRoleId(roleId);
         let server = await ServerlistModel.findByServerId(serverId);
-        let task = new CheckTask(serverId, roleId, TASK_TYPE.LOGIN_SUM, role.createTime, server.openTime);
-        task.param.setRole(role);
-        task.check(1, sid);
         return resResult(STATUS.SUCCESS)
     }
 }

game-server/app/services/normalBattleService.ts

@@ -8,8 +8,7 @@ import { FUNC_OPT_TYPE, TASK_TYPE, WAR_TYPE, STATUS, KING_EXP_RATIO_TYPE, ITEM_C
 import { BackendSession, pinus } from 'pinus';
 import { REDIS_KEY } from '../consts';
 import { Rank } from './rankService';
-import { checkActivityTask, checkTask } from './task/taskService';
+import { checkTask } from './task/taskService';
-import { accomplishTask } from '../pubUtils/taskUtil';
 import { RScriptRecordModel } from '../db/RScriptRecord';
 import { setAp } from './actionPointService';
 import { resResult } from '../pubUtils/util';
@@ -45,9 +44,7 @@ export async function roleLevelup(type: KING_EXP_RATIO_TYPE, roleId: string, kin
         await r.setRankWithRoleInfo(roleId, newLv, Date.now(), role);
 
         // 任务
-        await checkTask(roleId, session.get('sid'), TASK_TYPE.ROLE_LV, newLv, false, {});
+        await checkTask(serverId, roleId, session.get('sid'), TASK_TYPE.ROLE_LV, { oldLv: lv, lv: newLv });
-        //成长任务
-        await checkActivityTask(serverId, session.get('sid'), roleId, TASK_TYPE.ROLE_LV, newLv);
         // 弹出礼包
         await checkPopUpCondition(serverId, roleId, POP_UP_SHOP_CONDITION_TYPE.LV_TO, { oldLv: lv, newLv })
 

game-server/app/services/redisService.ts

@@ -307,8 +307,8 @@ export async function clearChannelServers() {
  * @param userCode user表唯一字符串标识
  * @param sid connector服的那个sid
  */
-export async function roleLogin(roleId: string, userCode: string, sid: string, pkgName: string) {
+export async function roleLogin(roleId: string, userCode: string, sid: string, pkgName: string, createTime: number) {
-    let param = { userCode, sid, pkgName };
+    let param = { userCode, sid, pkgName, createTime };
     return await redisClient().hsetAsync(REDIS_KEY.ONLINE_USERS, roleId, JSON.stringify(param));
 }
 
@@ -344,7 +344,8 @@ export async function getRoleOnlineInfo(roleId: string) {
                 isOnline: true,
                 userCode: result.userCode,
                 sid: result.sid,
-                pkgName: result.pkgName
+                pkgName: result.pkgName,
+                createtime: result.createTime
             }
         } catch(e) {
             return { isOnline: false }
@@ -354,6 +355,15 @@ export async function getRoleOnlineInfo(roleId: string) {
     }
 }
 
+export async function getRoleCreateTime(roleId: string) {
+    let onlineInfo = await getRoleOnlineInfo(roleId);
+    if(onlineInfo.isOnline) {
+        return onlineInfo.createtime;
+    } else {
+        return null
+    }
+}
+
 /**
  * 获得所有在线的玩家
  */
@@ -440,16 +450,16 @@ export async function readDataBase() {
 
 async function setServerList() {
     const serverList = await ServerlistModel.getAllServerList();
-    await redisClient().delAsync(REDIS_KEY.DB_GAME);
+    await redisClient().delAsync(REDIS_KEY.SERVER);
 
-    for(let { id, name } of serverList) {
+    for(let { id, name, openTime } of serverList) {
         // console.log(roleId);
-        await redisClient().hsetAsync(REDIS_KEY.DB_GAME, `${id}`, name);
+        await redisClient().hsetAsync(REDIS_KEY.SERVER, `${id}`, `${name}|${openTime}`);
     }
 }
 
 export async function getAllServers() {
-    let servers = await  redisClient().hgetallAsync(REDIS_KEY.DB_GAME);
+    let servers = await  redisClient().hgetallAsync(REDIS_KEY.SERVER);
     let serverlist = new Array<number>();
     for(let serverStr in servers) {
         let serverId = parseInt(serverStr);
@@ -462,10 +472,17 @@ export async function getAllServers() {
 }
 
 export async function getServerName(serverId: number) {
-    let name = await redisClient().hgetAsync(REDIS_KEY.DB_GAME, `${serverId}`);
+    let value = await redisClient().hgetAsync(REDIS_KEY.SERVER, `${serverId}`);
+    let name = value.split('|')[0];
     return name||'常山少年'
 }
 
+export async function getServerCreateTime(serverId: number) {
+    let value = await redisClient().hgetAsync(REDIS_KEY.SERVER, `${serverId}`);
+    let time = value.split('|')[1];
+    return parseInt(time);
+}
+
 export function redisClient() {
     const client: Redis.RedisClient = pinus.app.get('redis');
     return client;

game-server/app/services/role/createHero.ts

@@ -4,7 +4,6 @@ import { HeroModel, HeroSkin, HeroType, HeroUpdate } from "../../db/Hero";
 import { RoleModel, RoleType, RoleUpdate } from "../../db/Role";
 import { SkinUpdate } from "../../db/Skin";
 import { Figure, TopHero } from "../../domain/dbGeneral";
-import { accomplishTask, checkTask, checkTaskWithHeroes } from '../../pubUtils/taskUtil';
 import { combineFigureInfo, unlockFigureWithoutSave } from '../../pubUtils/itemUtils';
 import { TaskListReturn } from "../../domain/roleField/task";
 import { GuildModel, GuildType } from "../../db/Guild";
@@ -15,10 +14,10 @@ import { nowSeconds } from "../../pubUtils/timeUtil";
 import { saveCeChangeLog } from "../../pubUtils/logUtil";
 import { reduceCe, resResult } from "../../pubUtils/util";
 import { AttributeCal } from "../../domain/roleField/attribute";
-import { ActivityInRemote } from "../../domain/activityField/activityField";
 import { HeroShowParam } from "../../domain/roleField/hero";
 import { pinus } from "pinus";
 import { Rank } from "../rankService";
+import { checkTaskInCreateHero } from "../task/taskService";
 
 export class UpdateHeroes {
     roleId: string;
@@ -188,36 +187,17 @@ export class CreateHeroes extends UpdateHeroes {
         this.resultHeroes = await HeroModel.insertHeroes(this.roleId, this.roleName, this.serverId, heroeInfos);
     }
 
-    public async clearTask(activitiesTypeMap: ActivityInRemote[]) {
-        // 任务
-        // console.log('****** checkTask before', Date.now())
-        let m1 = await checkTask(this.roleId, TASK_TYPE.HERO_NUM, this.heroNum, true, {});
-        let m2 = await checkTaskWithHeroes(this.roleId, TASK_TYPE.HERO_QUALITY, this.resultHeroes);
-        let m3 = await checkTaskWithHeroes(this.roleId, TASK_TYPE.HERO_QUALITY_STAR_UP, this.resultHeroes);
-        let m4 = await checkTaskWithHeroes(this.roleId, TASK_TYPE.HERO_LV, this.resultHeroes);
-        this.taskPushMessage.push(...m1, ...m2, ...m3, ...m4);
-        // console.log('****** checkTask after', Date.now())
-        //成长任务
-        // console.log('****** accomplishTask before', Date.now())
-        let mm1 = await accomplishTask(this.serverId, this.roleId, TASK_TYPE.HERO_NUM, this.heroNum, null,  activitiesTypeMap)
-        console.log('****mn1', mm1)
-        let mm2 = await accomplishTask(this.serverId, this.roleId, TASK_TYPE.HERO_QUALITY, this.heroNum, { heroes: this.resultHeroes }, activitiesTypeMap);
-        // console.log('****** accomplishTask after', Date.now())
-        this.activityTaskPushMessage.push(...mm1, ...mm2);
-    }
-
     public async pushMessage(sid: string) {
         let role = await this.getRole();
         let uids = [{ uid: this.roleId, sid }];
         pinus.app.get('channelService').pushMessageByUids('onPlayerCeUpdate', resResult(STATUS.SUCCESS, { ce: reduceCe(role.ce) , heros: this.pushHeroes.map(cur => { return {...cur, ce: reduceCe(cur.ce), incHeroCe: reduceCe(cur.incHeroCe) }}), topLineupCe:  reduceCe(role.topLineupCe) }), uids);
-        pinus.app.get('channelService').pushMessageByUids('onTaskUpdate', resResult(STATUS.SUCCESS, this.taskPushMessage), uids);
-        pinus.app.get('channelService').pushMessageByUids('onActivityTaskUpdate', resResult(STATUS.SUCCESS, this.activityTaskPushMessage), uids);
         let figureInfo = combineFigureInfo(this.figureInfos);
         if (!!figureInfo && (figureInfo.heads.length > 0 || figureInfo.frames.length > 0 || figureInfo.spines.length > 0)) {
             pinus.app.get('channelService').pushMessageByUids('onHeadChange', resResult(STATUS.SUCCESS, { ...figureInfo }), uids);
         }
         pinus.app.get('channelService').pushMessageByUids('onHeroSkinChange', resResult(STATUS.SUCCESS, this.skinPushMessages), uids);
         pinus.app.get('channelService').pushMessageByUids('onHeroUpdate', resResult(STATUS.SUCCESS, { heroes: this.getResultHeroes() }), uids);
+        checkTaskInCreateHero(this.serverId, this.roleId, sid, this.heroNum, this.resultHeroes)
     }
 
     public getResultHeroes() {

game-server/app/services/role/rewardService.ts

@@ -600,7 +600,6 @@ export async function createHeroes(roleId: string, roleName: string, sid: string
     if (infos.size > 0) {
         let createHero = new CreateHeroes(roleId, roleName, serverId);
         await createHero.createWithHeroInfo(infos);
-        await createHero.clearTask(await getActivities())
         await createHero.pushMessage(sid);
         await createHero.updateRedisRank();
         heroes = createHero.getShowHeroes();

game-server/app/services/task/taskObj.ts

@@ -1,5 +1,6 @@
 import { pinus } from "pinus";
-import { ACTIVITY_TYPE, STATUS, TASK_SUM_TYPE, TASK_TYPE } from "../../consts";
+import { ABI_STAGE, ACTIVITY_TYPE, STATUS, TASK_SUM_TYPE, TASK_TYPE, WAR_TYPE } from "../../consts";
+import { ActivityModelType } from "../../db/Activity";
 import { ActivityBuyRecordsModel } from "../../db/ActivityBuyRecords";
 import { ActivityDailyChallengesModel } from "../../db/ActivityDailyChallenges";
 import { ActivityGrowthModel } from "../../db/ActivityGrowth";
@@ -7,7 +8,7 @@ import { ActivityGrowthFundModel } from "../../db/ActivityGrowthFund";
 import { ActivityRefreshTaskModel } from "../../db/ActivityRefreshTask";
 import { ActivityThirtyDaysModel } from "../../db/ActivityThirtyDays";
 import { ActivityTreasureHuntTaskModel } from "../../db/ActivityTreasureHuntTask";
-import { RoleType } from "../../db/Role";
+import { RoleModel, RoleType } from "../../db/Role";
 import { ServerTempModel, ServerTempModelType } from "../../db/ServerTemp";
 import { UserTaskRecModel } from "../../db/UserTaskRec";
 import { GrowthFundData } from "../../domain/activityField/growthFundField";
@@ -15,57 +16,169 @@ import { RefreshTaskData } from "../../domain/activityField/refreshTaskField";
 import { SevenDaysData } from "../../domain/activityField/sevenDaysField";
 import { ThirtyDaysData } from "../../domain/activityField/thirtyDaysField";
 import { TreasureHuntData } from "../../domain/activityField/treasureHuntField";
-import { TaskListReturn, UpdateTaskParam } from "../../domain/roleField/task";
+import { TaskListReturn, TaskParam, TaskParamInter, UpdateTaskParam } from "../../domain/roleField/task";
 import { gameData } from "../../pubUtils/data";
 import { getZeroPoint } from "../../pubUtils/timeUtil";
 import { resResult } from "../../pubUtils/util";
 import { getActivities, getActivitiesByType, getActivityByServerId } from "../activity/activityService";
-import { getRoleOnlineInfo } from "../redisService";
+import { getRoleCreateTime, getRoleOnlineInfo, getServerCreateTime } from "../redisService";
+
+export class CheckTask {
+    serverId: number;       // 区id
+    roleId: string;         // 玩家id
+    role?: RoleType;
+    roleCreateTime: number; // 玩家的创建时间
+    serverCreateTime: number; // 服务器的创建时间
+
+    taskPushMessages: TaskListReturn[] = [];
+    activityTaskPushMessages = [];
+
+    treasureHuntTemp: ServerTempModelType;
+    tasks: CheckSingleTask[] = [];
+    
+    constructor(serverId: number, roleId: string) {
+        this.serverId = serverId;
+        this.roleId = roleId;
+    }
+
+    public setParam(taskType: TASK_TYPE, param: TaskParamInter) {
+        let task = new CheckSingleTask(taskType, this);
+        task.param.setParam(param);
+        this.tasks.push(task);
+    }
+
+    public async saveAndPush(sid: string) {
+        for(let task of this.tasks) {
+            await task.check();
+        }
+        await this.pushMessage(sid);
+    }
+
+    public setRole(role: RoleType) {
+        this.role = role;
+    }
+
+    // 用于活动任务：获取服务器开服时间
+    async getServerCreateTime() {
+        if(!this.serverCreateTime) {
+            this.serverCreateTime = await getServerCreateTime(this.serverId);
+        }
+        return this.serverCreateTime;
+    }
+
+    // 用于活动任务：获取玩家创建时间
+    async getRoleCreateTime() {
+        if(!this.roleCreateTime) {
+            if(this.role) {
+                this.roleCreateTime = this.role?.createTime;
+            } else {
+                this.roleCreateTime = await getRoleCreateTime(this.roleId);
+            }
+        }
+        if(!this.roleCreateTime) {
+            let role = await RoleModel.findByRoleId(this.roleId);
+            this.role = role;
+            this.roleCreateTime = role.createTime;
+        }
+        return this.roleCreateTime;
+    }
+
+    // 神州探秘活动
+    async getTreasureHuntTemp() {
+        if(this.treasureHuntTemp) return this.treasureHuntTemp;
+
+        let tempData: ServerTempModelType = await ServerTempModel.findData(this.serverId);
+        if (tempData) {
+            this.treasureHuntTemp = tempData;
+            return tempData
+        } else {
+            return null
+        }    
+    }
+
+    // 推送
+    public async pushMessage(sid: string) {
+        let roleId = this.roleId;
+        if (!sid) {
+            let onlineUser = await getRoleOnlineInfo(roleId);
+            sid = onlineUser.sid;
+        }
+        let uids = [{ uid: roleId, sid }];
+        if(!!sid) {
+            if (this.taskPushMessages.length > 0) {
+                pinus.app.get('channelService').pushMessageByUids('onTaskUpdate', resResult(STATUS.SUCCESS, this.taskPushMessages), uids);
+            }
+            if (this.activityTaskPushMessages.length > 0) {
+                pinus.app.get('channelService').pushMessageByUids('onActivityTaskUpdate', resResult(STATUS.SUCCESS, this.activityTaskPushMessages), uids);
+            }
+        }
+    }
+
+}
 
 /**
  * @class CheckTask
  * @classdesc 检查某个玩家任务的达成情况
  */
-export class CheckTask {
+export class CheckSingleTask {
     serverId: number;       // 区id
     roleId: string;         // 玩家id
     taskType: TASK_TYPE;    // 任务type
-    roleCreateTime: number; // 玩家的创建时间
+    parent: CheckTask;
-    serverCreateTime: number; // 服务器的创建时间
-
     param: TaskParam;           // 检查任务时传入的参数
 
-    treasureHuntTemp: ServerTempModelType;
+    constructor(taskType: TASK_TYPE, parent: CheckTask) {
-
-    constructor(serverId: number, roleId: string, taskType: TASK_TYPE, roleCreateTime: number, serverCreateTime: number) {
-        this.serverId = serverId;
-        this.roleId = roleId;
         this.taskType = taskType;
-        this.roleCreateTime = roleCreateTime;
+        this.parent = parent;
-        this.serverCreateTime = serverCreateTime;
+        this.serverId = parent.serverId;
+        this.roleId = parent.roleId;
         this.param = new TaskParam();
     }
 
+    private addTaskPushMessage(...param: TaskListReturn[]) {
+        this.parent.taskPushMessages.push(...param);
+    }
+
+    private addActivityTaskPushMessage(...param: any[]) {
+        this.parent.activityTaskPushMessages.push(...param);
+    }
+
+    private getServerCreateTime() {
+        return this.parent.getServerCreateTime();
+    }
+
+    private getRoleCreateTime() {
+        return this.parent.getRoleCreateTime();
+    }
+
+    private getRole() {
+        return this.parent.role;
+    }
+
     /**
      * @description 检查任务的主程序
      */
-    public async check(count: number, sid: string) {
+    public async check() {
-        let { taskType, roleId, serverId, roleCreateTime, serverCreateTime } = this;
+        let { taskType, roleId, serverId } = this;
+        let serverCreateTime = await this.getServerCreateTime();
+        let roleCreateTime = await this.getRoleCreateTime();
+        let param = this.param;
         let dicTaskTypeDesc = gameData.taskDescByType.get(taskType);
-        let taskPushMessages: TaskListReturn[] = [];
-        let activityTaskPushMessages = [];
         
         // 检查一般任务
         let dicTasks = gameData.taskType.get(taskType);
         for (let dicTask of dicTasks) {
     
-            let taskUpdateParam = this.checkIsMatch(dicTask.taskParam, count);
+            let taskUpdateParam = await this.checkIsMatch(dicTask.taskParam, async () => {
+                let data = await UserTaskRecModel.findByRoleAndGroup(roleId, dicTask.type, taskType, dicTask.group);
+                return data? data.records: []
+            });
             if (taskUpdateParam) {
-                let rec = await UserTaskRecModel.checkAndUpdateTask(roleId, dicTask.type, taskType, dicTask.group, taskUpdateParam);
+                let rec = await UserTaskRecModel.setOrIncTask(roleId, dicTask.type, taskType, dicTask.group, taskUpdateParam);
                 if (!rec) continue;
                 if (rec.received && rec.received.includes(dicTask.id)) continue; // 已领取，不再推送
                 let received = rec.received || [];
-                taskPushMessages.push({ type: dicTask.type, id: dicTask.id, count: rec.count, received: received.includes(dicTask.id) });
+                this.addTaskPushMessage({ type: dicTask.type, id: dicTask.id, count: rec.count, received: received.includes(dicTask.id) });
 
             }
         }
@@ -83,11 +196,14 @@ export class CheckTask {
                         let playerData = new SevenDaysData(activity, roleCreateTime, serverCreateTime);
                         let growthTaskArray = playerData.growth.findTaskByType(taskType); // 所有任务
                         for (let task of growthTaskArray) {
-                            let taskUpdateParam = this.checkIsMatch(task.taskParamArray, count);
+                            let taskUpdateParam = await this.checkIsMatch(task.taskParamArray, async () => {
+                                let data = await ActivityGrowthModel.findDataByCellIndex(serverId, activityId, roleId, task.dayIndex, task.cellIndex);
+                                return data? data.records: []
+                            });
                             if(taskUpdateParam) {
-                                let rec = await ActivityGrowthModel.checkAndUpdateTask(serverId, activityId, roleId, task.dayIndex, task.cellIndex, taskUpdateParam);
+                                let rec = await ActivityGrowthModel.setOrIncTask(serverId, activityId, roleId, task.dayIndex, task.cellIndex, taskUpdateParam);
                                 if(!rec) continue;
-                                activityTaskPushMessages.push({...task, totalCount: rec.totalCount, receiveRewardCount: rec.receiveRewardCount||0, activityId, activityType: "growth" });
+                                this.addActivityTaskPushMessage({...task, totalCount: rec.totalCount, receiveRewardCount: rec.receiveRewardCount||0, activityId, activityType: "growth" });
                             }
                         }
                         //今日挑战统计
@@ -96,11 +212,14 @@ export class CheckTask {
                             if(dicTaskTypeDesc.sumType == TASK_SUM_TYPE.DO && task.dayIndex != playerData.today()) {
                                 continue;
                             }
-                            let taskUpdateParam = this.checkIsMatch(task.taskParamArray, count);
+                            let taskUpdateParam = await this.checkIsMatch(task.taskParamArray, async () => {
+                                let data = await ActivityDailyChallengesModel.findDataByCellIndex(serverId, activityId, roleId, task.dayIndex, task.cellIndex);
+                                return data? data.records: []
+                            });
                             if(taskUpdateParam) {
-                                let rec = await ActivityDailyChallengesModel.checkAndUpdateTask(serverId, activityId, roleId, task.dayIndex, task.cellIndex, taskUpdateParam);
+                                let rec = await ActivityDailyChallengesModel.setOrIncTask(serverId, activityId, roleId, task.dayIndex, task.cellIndex, taskUpdateParam);
                                 if(!rec) continue;
-                                activityTaskPushMessages.push({...task, totalCount: rec.totalCount, receiveRewardCount: rec.receiveRewardCount||0, activityId, activityType: "daily" });
+                                this.addActivityTaskPushMessage({...task, totalCount: rec.totalCount, receiveRewardCount: rec.receiveRewardCount||0, activityId, activityType: "daily" });
                             }
                         }
                         break;
@@ -111,11 +230,14 @@ export class CheckTask {
                         let taskActivity = new RefreshTaskData(activity, roleCreateTime, serverCreateTime);
                         let taskArray = taskActivity.findTaskByType(taskType);
                         for (let task of taskArray) {
-                            let taskUpdateParam = this.checkIsMatch(task.taskParamArray, count);
+                            let taskUpdateParam = await this.checkIsMatch(task.taskParamArray, async () => {
+                                let data = await ActivityRefreshTaskModel.findDataById(serverId, activityId, roleId, taskActivity.roundIndex, task.pageIndex, task.id);
+                                return data? data.records: []
+                            });
                             if(taskUpdateParam) {
-                                let rec = await ActivityRefreshTaskModel.checkAndUpdateTask(serverId, activityId, roleId, taskActivity.roundIndex, task.pageIndex, task.id, taskUpdateParam);
+                                let rec = await ActivityRefreshTaskModel.setOrIncTask(serverId, activityId, roleId, taskActivity.roundIndex, task.pageIndex, task.id, taskUpdateParam);
                                 if(!rec) continue;
-                                activityTaskPushMessages.push({...task, totalCount: rec.totalCount, receiveRewardCount: rec.receiveRewardCount||0, activityId });
+                                this.addActivityTaskPushMessage({...task, totalCount: rec.totalCount, receiveRewardCount: rec.receiveRewardCount||0, activityId });
                             }
                         }
                         break;
@@ -123,16 +245,19 @@ export class CheckTask {
                 case ACTIVITY_TYPE.TREASURE_HUNT:
                     {
                         // 寻宝奇兵任务
-                        let tempData = await this.getTreasureHuntTemp();
+                        let tempData = await this.parent.getTreasureHuntTemp();
                         if(tempData && tempData.huntActivityId == activityId) {
                             let playerData = new TreasureHuntData(activity, roleCreateTime, serverCreateTime);
                             let taskArray = playerData.tasks.findItemByTaskType(taskType);
                             for (let task of taskArray) {
-                                let taskUpdateParam = this.checkIsMatch(task.taskParamArray, count);
+                                let taskUpdateParam = await this.checkIsMatch(task.taskParamArray, async () => {
+                                    let data = await ActivityTreasureHuntTaskModel.findDataByCellIndex(serverId, activityId, roleId, tempData.huntRoundIndex, task.cellIndex);
+                                    return data? data.records: [];
+                                });
                                 if(taskUpdateParam) {
-                                    let rec = await ActivityTreasureHuntTaskModel.checkAndUpdateTask(serverId, activityId, roleId, tempData.huntRoundIndex, task.cellIndex, taskUpdateParam);
+                                    let rec = await ActivityTreasureHuntTaskModel.setOrIncTask(serverId, activityId, roleId, tempData.huntRoundIndex, task.cellIndex, taskUpdateParam);
                                     if(!rec) continue;
-                                    activityTaskPushMessages.push({ ...task, totalCount: rec.totalCount, activityId });
+                                    this.addActivityTaskPushMessage({ ...task, totalCount: rec.totalCount, activityId });
                                 }
                             }
                         }
@@ -144,11 +269,14 @@ export class CheckTask {
                         let thirtyDaysActivity = new ThirtyDaysData(activity, roleCreateTime, serverCreateTime);
                         let taskArray = thirtyDaysActivity.findTaskByType(taskType);
                         for (let task of taskArray) {
-                            let taskUpdateParam = this.checkIsMatch(task.taskParamArray, count);
+                            let taskUpdateParam = await this.checkIsMatch(task.taskParamArray, async () => {
+                                let data = await ActivityThirtyDaysModel.findDataByCellIndex(serverId, thirtyDaysActivity.activityId, roleId, task.pageIndex, task.cellIndex, task.tab);
+                                return data? data.records: [];                                
+                            });
                             if(taskUpdateParam) {
-                                let rec = await ActivityThirtyDaysModel.checkAndUpdateTask(serverId, thirtyDaysActivity.activityId, roleId, task.pageIndex, task.cellIndex, task.tab, taskUpdateParam);
+                                let rec = await ActivityThirtyDaysModel.setOrIncTask(serverId, thirtyDaysActivity.activityId, roleId, task.pageIndex, task.cellIndex, task.tab, taskUpdateParam);
                                 if(!rec) continue;
-                                activityTaskPushMessages.push({ ...task, totalCount: rec.totalCount, activityId });
+                                this.addActivityTaskPushMessage({ ...task, totalCount: rec.totalCount, activityId });
                             }
                         }
                         break;
@@ -158,17 +286,7 @@ export class CheckTask {
                     {
                         //主线成长基金
                         if(taskType != TASK_TYPE.BATTLE_MAIN) continue;
-
+                        await this.checkFundAcctivityTask(activity, param.warId);
-                        let growthFundActivity = new GrowthFundData(activity, roleCreateTime, serverCreateTime);
-                        let playerRecords = await ActivityGrowthFundModel.findData(activity.activityId, roleId);
-                        growthFundActivity.setPlayerRecords(playerRecords);
-                        if (growthFundActivity.isVipActivity()) {//vip高阶需要购买
-                            let buyRecords = await ActivityBuyRecordsModel.findRecordsByActivityId(activity.activityId, roleId);
-                            growthFundActivity.initBuyRecords(buyRecords);
-                        }
-                        let taskArray = growthFundActivity.unLockItem(this.param.warId);
-                        //推送
-                        activityTaskPushMessages.push(...taskArray);
                         break;
                     }
                 case ACTIVITY_TYPE.GROWTH_FUND_TOWER:
@@ -176,17 +294,7 @@ export class CheckTask {
                     {
                         //镇念塔成长基金
                         if(taskType != TASK_TYPE.BATTLE_TOWER_LV) continue;
-
+                        await this.checkFundAcctivityTask(activity, param.towerLv);
-                        let growthFundActivity = new GrowthFundData(activity, roleCreateTime, serverCreateTime);
-                        let playerRecords = await ActivityGrowthFundModel.findData(activity.activityId, roleId);
-                        growthFundActivity.setPlayerRecords(playerRecords);
-                        if (growthFundActivity.isVipActivity()) {//vip高阶需要购买
-                            let buyRecords = await ActivityBuyRecordsModel.findRecordsByActivityId(activity.activityId, roleId);
-                            growthFundActivity.initBuyRecords(buyRecords);
-                        }
-                        let taskArray = growthFundActivity.unLockItem(this.param.towerLv);
-                        //推送
-                        activityTaskPushMessages.push(...taskArray);
                         break;
                     }
                 case ACTIVITY_TYPE.GROWTH_FUND_MAIN_ELITE:
@@ -194,77 +302,448 @@ export class CheckTask {
                     {
                         //精英成长基金
                         if(taskType != TASK_TYPE.BATTLE_MAIN_ELITE) continue;
-
+                        await this.checkFundAcctivityTask(activity, param.warId);
-                        let growthFundActivity = new GrowthFundData(activity, roleCreateTime, serverCreateTime);
-                        let playerRecords = await ActivityGrowthFundModel.findData(activity.activityId, roleId);
-                        growthFundActivity.setPlayerRecords(playerRecords);
-                        if (growthFundActivity.isVipActivity()) {//vip高阶需要购买
-                            let buyRecords = await ActivityBuyRecordsModel.findRecordsByActivityId(activity.activityId, roleId);
-                            growthFundActivity.initBuyRecords(buyRecords);
-                        }
-                        let taskArray = growthFundActivity.unLockItem(this.param.warId);
-                        //推送
-                        activityTaskPushMessages.push(...taskArray);
                         break;
                     }
             }
         }
 
-        if (taskPushMessages.length > 0) {
-            if (!sid) {
-                let onlineUser = await getRoleOnlineInfo(roleId);
-                sid = onlineUser.sid;
-            }
-            if (!!sid) {
-                let uids = [{ uid: roleId, sid }];
-                pinus.app.get('channelService').pushMessageByUids('onTaskUpdate', resResult(STATUS.SUCCESS, taskPushMessages), uids);
-            }
-        }
-        if (activityTaskPushMessages?.length > 0) {
-            if (!sid) {
-                let onlineUser = await getRoleOnlineInfo(roleId);
-                sid = onlineUser.sid;
-            }
-            if (!!sid) {
-                let uids = [{ uid: roleId, sid }];
-                pinus.app.get('channelService').pushMessageByUids('onActivityTaskUpdate', resResult(STATUS.SUCCESS, activityTaskPushMessages), uids);
-            }
-        }
     }
 
-    public checkIsMatch(dicTaskParam: number[], count: number): UpdateTaskParam {
+    private async checkFundAcctivityTask(activity: ActivityModelType, unlockParam: number) {
+        let serverCreateTime = await this.getServerCreateTime();
+        let roleCreateTime = await this.getRoleCreateTime();
+        let growthFundActivity = new GrowthFundData(activity, roleCreateTime, serverCreateTime);
+        let playerRecords = await ActivityGrowthFundModel.findData(activity.activityId, this.roleId);
+        growthFundActivity.setPlayerRecords(playerRecords);
+        if (growthFundActivity.isVipActivity()) {//vip高阶需要购买
+            let buyRecords = await ActivityBuyRecordsModel.findRecordsByActivityId(activity.activityId, this.roleId);
+            growthFundActivity.initBuyRecords(buyRecords);
+        }
+        let taskArray = growthFundActivity.unLockItem(unlockParam);
+        //推送
+        this.addActivityTaskPushMessage(...taskArray);
+    }
+
+    public async checkIsMatch(dicTaskParam: number[], getRecord: () => Promise<string[]>) {
         let param = this.param;
+        let result: UpdateTaskParam = null;
         switch(this.taskType) {
-            case TASK_TYPE.LOGIN_SUM:
+            case TASK_TYPE.LOGIN_SUM: // 1. 累计登录 x 天
                 {
+                    let role = this.getRole();
                     let today = getZeroPoint();
-                    if (today > param.role.loginTime) {
+                    if (today > role.loginTime) {
-                        return { inc: count }
+                        result = { inc: 1 }
                     }
+                    break;
+                }
+            case TASK_TYPE.LOGIN_SERIES: // 2. 连续登录 x 天
+                {
+                    let role = this.getRole();
+                    let today = getZeroPoint();
+                    if (today > role.loginTime) {
+                        if (today - role.loginTime > 24 * 60 * 60) {
+                            result = { set: 1 }
+                        } else {
+                            result = { inc: 1 }
+                        }
+                    }
+                    break;
+                }
+            case TASK_TYPE.ROLE_LV: // 3. 主公达x级
+                {
+                    let { lv, oldLv } = param;
+                    if(oldLv < dicTaskParam[0] && lv >= dicTaskParam[0]) {
+                        result = { set: lv }
+                    }
+                    break;
+                }
+            case TASK_TYPE.GACHA: // 4. 招募x次
+                {
+                    let { count } = param;
+                    result = { inc: count };
+                    break;
+                }
+            case TASK_TYPE.HERO_NUM: // 5. 拥有x名武将
+                {
+                    let { heroNum } = param;
+                    result = { inc: heroNum };
+                    break;
+                }
+            case TASK_TYPE.HERO_STAR_UP: // 6. x名武将升星x次
+                {
+                    let { hero } = param;
+                    let records = await getRecord();
+                    let count = 0, index = -1;
+                    for(let i = 0; i < records.length; i++) {
+                        let arr = records[i].split('|');
+                        if(parseInt(arr[0]) == hero.hid) {
+                            count = parseInt(arr[1]);
+                            index = i;
+                            break;
+                        }
+                    }
+                    if(count + 1 >= dicTaskParam[1]) {
+                        records[index] = `${hero.hid}_${count + 1}`;
+                        result = { inc: 1, records }
+                    } else {
+                        records.push(`${hero.hid}_${count + 1}`);
+                        result = { records }
+                    }
+                    break;
+                }
+            case TASK_TYPE.HERO_QUALITY: // 7. 拥有x名初始x品质武将
+                {
+                    let { heroes } = param;
+                    let num = 0;
+                    for(let { hid } of heroes) {
+                        let dicHero = gameData.hero.get(hid);
+                        if(dicHero.quality == dicTaskParam[1]) {
+                            num ++;
+                        }
+                    }
+                    result = { inc: num };
+                    break;
+                }
+            case TASK_TYPE.HERO_QUALITY_STAR_UP: // 8. x名x品质升至x星
+                {
+                    let { heroes, hero, oldStar } = param;
+                    if(param.heroes) { // 创建武将的时候
+                        let num = 0;
+                        for(let { hid, star } of heroes) {
+                            let dicHero = gameData.hero.get(hid);
+                            if(dicHero.quality == dicTaskParam[1] && star == dicTaskParam[2]) {
+                                num ++;
+                            }
+                        }
+                        result = { inc: num };
+                    } else { // 武将升星的时候
+                        let dicHero = gameData.hero.get(hero.hid);
+                        if(dicHero.quality == dicTaskParam[1] && hero.star >= dicTaskParam[2] && oldStar < dicTaskParam[2]) {
+                            result = { inc: 1 }
+                        }
+                    }
+                    break;
+                }
+            case TASK_TYPE.HERO_LV: // 9. x名武将升至x级
+                {
+                    let { heroes, hero, oldLv } = param;
+                    if(heroes) { // 创建武将的时候
+                        let num = 0;
+                        for(let { lv } of heroes) {
+                            if(lv >= dicTaskParam[1]) {
+                                num ++;
+                            }
+                        }
+                        result = { inc: num };
+                    } else { // 武将升级的时候
+                        if(hero.lv >= dicTaskParam[1] && oldLv < dicTaskParam[1]) {
+                            result = { inc: 1 }
+                        }
+                    }
+                    break;
+                }
+            case TASK_TYPE.HERO_TRAIN: // 10. x名武将各训练x次
+                {
+                    let { hero, trainCount } = param;
+                    let records = await getRecord();
+                    let count = 0, index = -1;
+                    for(let i = 0; i < records.length; i++) {
+                        let arr = records[i].split('|');
+                        if(parseInt(arr[0]) == hero.hid) {
+                            count = parseInt(arr[1]);
+                            index = i;
+                            break;
+                        }
+                    }
+                    if( count < dicTaskParam[1] && count + trainCount >= dicTaskParam[1]) {
+                        records[index] = `${hero.hid}_${count + trainCount}`;
+                        result = { inc: 1, records }
+                    } else {
+                        records.push(`${hero.hid}_${count + trainCount}`);
+                        result = { records }
+                    }
+                    break;
+                }
+            case TASK_TYPE.HERO_QUALITY_UP: // 11. x名武将进行升品
+                {
+                    let { hero } = param;
+                    let records = await getRecord();
+                    if(records.indexOf(`${hero.hid}`) == -1) {
+                        records.push(`${hero.hid}`);
+                        result = { records, inc: 1 };
+                    }
+                    break;
+                }
+            case TASK_TYPE.HERO_WAKE_UP: // 12.武将觉醒x次
+                {
+                    let { hero, oldColorStar } = param;
+                    if(oldColorStar == 0 && hero.colorStar > 0) {
+                        result = { inc: 1 };
+                    }
+                    break;
+                }
+            case TASK_TYPE.HERO_TRAIN_SUM: // 13. 训练x次
+                {
+                    let { trainCount } = param;
+                    result = { inc: trainCount };
+                    break;
+                }
+            case TASK_TYPE.HERO_STAGE_UP: // 14. x名武将各兵种进阶x次
+                {
+                    let { hero, stageUpCnt } = param;
+                    let records = await getRecord();
+                    let count = 0, index = -1;
+                    for(let i = 0; i < records.length; i++) {
+                        let arr = records[i].split('|');
+                        if(parseInt(arr[0]) == hero.hid) {
+                            count = parseInt(arr[1]);
+                            index = i;
+                            break;
+                        }
+                    }
+                    if( count < dicTaskParam[1] && count + stageUpCnt >= dicTaskParam[1]) {
+                        records[index] = `${hero.hid}_${count + stageUpCnt}`;
+                        result = { inc: 1, records }
+                    } else {
+                        records.push(`${hero.hid}_${count + stageUpCnt}`);
+                        result = { records }
+                    }
+                    break;
+                }
+            case TASK_TYPE.HERO_FAVOUR_LV: // 15. 
+                {
+                    let { hero, oldFavourLv } = param;
+                    if(dicTaskParam[1] > oldFavourLv && dicTaskParam[1] <= hero.favourLv) {
+                        result = { inc: 1 };
+                    }
+                    break;
+                }
+            case TASK_TYPE.HERO_CONNECT: // 16. 激活x次 x星 武将羁绊
+                {
+                    let { connectLv } = param;
+                    if(dicTaskParam[1] == connectLv) {
+                        result = { inc: 1 };
+                    }
+                    break;
+                }
+            case TASK_TYPE.CHAT:
+                {
+                    if (dicTaskParam[0] == 0 || dicTaskParam[0] == param.chatType) {
+                        result = { inc: param.count };
+                    }
+                    break;
+                }
+            case TASK_TYPE.FRIEND_NUM:
+                {
+                    let role = this.getRole();
+                    result = { set: role.friendCnt };
+                    break;
+                }
+            case TASK_TYPE.BATTLE_WITH_HERO: // 38. 使用hId武将挑战x关卡x次
+                {
+                    let { warId, battleHeroes } = param;
+                    if(this.checkIdList(dicTaskParam, 2, warId) && battleHeroes.indexOf(dicTaskParam[0]) != -1) {
+                        result = { inc: 1 };
+                    }
+                    break;
+                }
+            case TASK_TYPE.BATTLE_MAIN: // 39. 主线通关第x关
+                {
+                    let { warId, count } = param;
+                    let dicWar = gameData.war.get(warId);
+                    if (dicWar.warType == WAR_TYPE.NORMAL) {
+                        result = { inc: count };
+                    }
+                    break;
+                }
+            case TASK_TYPE.BATTLE_MAIN_SWEEP: // 40. 主线扫荡X次
+                {
+                    let { warId, count } = param;
+                    let dicWar = gameData.war.get(warId);
+                    if (dicWar.warType == WAR_TYPE.NORMAL) {
+                        result = { inc: count }
+                    }
+                    break;
+                }
+            case TASK_TYPE.BATTLE_DAILY_STAR: // 42. 每日x星通关 x 次
+                {
+                    let { warId, battleStar } = param;
+                    let dicWar = gameData.war.get(warId);
+                    if (dicWar.warType == WAR_TYPE.DAILY && (dicTaskParam[0] == 0|| dicTaskParam[0] == battleStar) && this.checkIdList(dicTaskParam, 2, warId)) {
+                        result = { inc: 1 }
+                    }
+                    break;
+                }
+            case TASK_TYPE.BATTLE_DAILY: // 43. 每日关卡挑战x次
+                {
+                    let { warId, count } = param;
+                    let dicWar = gameData.war.get(warId);
+                    if(dicTaskParam[0] == 0 || dicTaskParam[0] == dicWar.dailyType) {
+                        result = { inc: count };
+                    }
+                    break;
+                }
+            case TASK_TYPE.BATTLE_DUNGEON: // 44. 参与秘境x次
+                {
+                    let { warId, count } = param;
+                    let dicWar = gameData.war.get(warId);
+                    if(dicWar.warType == WAR_TYPE.MYSTERY || dicWar.warType == WAR_TYPE.MYSTERY_ELITE) {
+                        result = { inc: count };
+                    }
+                    break;
+                }
+            case TASK_TYPE.BATTLE_DUNGEON_WAR: // 45. 秘境通关x关x难度
+                {
+                    let { warId, count } = param;
+                    let dicWar = gameData.war.get(warId);
+                    if (dicWar.warType == WAR_TYPE.MYSTERY || dicWar.warType == WAR_TYPE.MYSTERY_ELITE && this.checkIdList(dicTaskParam, 0, warId)) {
+                        result = { inc: count };
+                    }
+                    break;
+                }
+            case TASK_TYPE.BATTLE_TOWER: // 47. 通关镇念塔x次
+                {
+                    let { warId, count } = param;
+                    let dicWar = gameData.war.get(warId);
+                    if (dicWar.warType == WAR_TYPE.TOWER) {
+                        result = { inc: count };
+                    }
+                    break;
+                }
+            case TASK_TYPE.BATTLE_VESTIGE: // 48. 挑战遗迹x次
+                {
+                    let { warId, count } = param;
+                    let dicWar = gameData.war.get(warId);
+                    if (dicWar.warType == WAR_TYPE.VESTIGE) {
+                        result = { inc: count };
+                    }
+                    break;
+                }
+            case TASK_TYPE.BATTLE_EXPEDITION: // 49. 开启远征x次
+                {
+                    let { warId, count } = param;
+                    let dicWar = gameData.war.get(warId);
+                    if (dicWar.warType == WAR_TYPE.EXPEDITION) {
+                        result = { inc: count };
+                    }
+                    break;
+                }
+            case TASK_TYPE.COM_BATTLE_CREATE_TEAM: // 51. 寻宝招募队友x次
+                {
+                    result = { inc: 1 };
+                    break;
+                }
+            case TASK_TYPE.COM_BATTLE_ASSIST_TEAM: // 53. 协助寻宝x次
+                {
+                    result = { inc: 1 };
+                    break;
+                }
+            case TASK_TYPE.COM_BATTLE: // 54. 组队寻宝
+                {
+                    result = { inc: 1 };
+                    break;
+                }
+            case TASK_TYPE.PVP_RECEIVE_BOX: // 59. 领取x次pvp巅峰之路宝箱
+                {
+                    result = { inc: 1 };
+                    break;
+                }
+            case TASK_TYPE.PVP: // 57. pvp挑战 x 次
+                {
+                    result = { inc: 1 };
+                    break;
+                }
+            case TASK_TYPE.PVP_WIN: // 58. pvp胜利 x 次
+                {
+                    let { isSuccess } = param;
+                    if(isSuccess) {
+                        result = { inc: 1 };
+                    }
+                    break;
+                }
+            case TASK_TYPE.PVP_WIN_SERIES: // 60. pvp连胜x次
+                {
+                    let { isSuccess } = param;
+                    if (isSuccess) {
+                        result = { inc: 1 };
+                    } else {
+                        result = { set: 0 };
+                    }
+                    break;
+                }
+            case TASK_TYPE.PVP_HERO_SCORE: // 61. pvp拥有x个积分达到x的武将
+                {
+                    let { heroScores } = param;
+                    let count = 0;
+                    for (let { score } of heroScores) {
+                        if (score >= dicTaskParam[0]) {
+                            count++;
+                        }
+                    }
+                    if (count > 0) {
+                        result = { set: count };
+                    }
+                    break;
+                    
+                }
+            case TASK_TYPE.HERO_QUALITY_TO_QUALITY_COUNT: // 74. x名初始x品质武将升至X品质
+                {
+                    let { hero } = param;
+                    let dicHero = gameData.hero.get(hero.hid);
+                    if(dicHero.quality == dicTaskParam[1] && hero.quality == dicTaskParam[2]) {
+                        result = { inc: 1 };
+                    }
+                    break;
+                }
+            case TASK_TYPE.HERO_QUALITY_WAKE_UP_COUNT: // 75. x名初始x品质武将觉醒
+                {
+                    let { hero, oldColorStar } = param;
+                    let dicHero = gameData.hero.get(hero.hid);
+                    if(dicTaskParam[1] == dicHero.quality && oldColorStar == 0 && hero.colorStar > 0) {
+                        result = { inc: 1 };
+                    }
+                    break;
+                }
+            case TASK_TYPE.HERO_WAKE_UP_STAR_UP_COUNT: // 76. x名武将觉醒后升至x星
+                {
+                    let { hero, oldColorStar } = param;
+                    if(dicTaskParam[1] > oldColorStar && hero.colorStar >= dicTaskParam[1]) {
+                        result = { inc: 1 };
+                    }
+                    break;
+                }
+            case TASK_TYPE.GACHA_QUALITY_COUNT: // 81. 抽到*次品质*武将
+                {
+                    let { heroes } = param;
+                    let count = 0;
+                    for (let hero of heroes) {
+                        let dicHero = gameData.hero.get(hero.hid);
+                        if(dicHero.quality == dicTaskParam[1]) count++;
+                    }
+                    if(count > 0) {
+                        result = { inc: count };
+                    }
+                    break;
+                }
+            case TASK_TYPE.HERO_WAKE_UP_COUNT: // 84. x名武将觉醒
+                {
+                    let { hero, oldColorStar } = param;
+                    if(oldColorStar == 0 && hero.colorStar > 0) {
+                        result = { inc: 1 };
+                    }
+                    break;
                 }
         }
+        return result
     }
-
+    
-    private async getTreasureHuntTemp() {
+    private checkIdList(taskParam: number[], index: number, id: number) {
-        if(this.treasureHuntTemp) return this.treasureHuntTemp;
+        let count = taskParam[index];
-
+        if (!count) return false;
-        let tempData: ServerTempModelType = await ServerTempModel.findData(this.serverId);
+        let idList = taskParam.slice(index + 1, index + 1 + count);
-        if (tempData) {
+        return idList.indexOf(id) != -1;
-            this.treasureHuntTemp = tempData;
-            return tempData
-        } else {
-            return null
-        }    
     }
-}
+    
-
-class TaskParam {
-    role?: RoleType;          // 玩家数据
-    warId?: number;
-    towerLv?: number;
-
-    public setRole(role: RoleType) {
-        this.role = role;
-    }
-
 }

game-server/app/services/task/taskService.ts

@@ -1,9 +1,8 @@
-import * as taskUtil from '../../pubUtils/taskUtil';
 import { RoleModel, RoleType } from '../../db/Role';
 import { pinus, FrontendOrBackendSession } from 'pinus';
 import { resResult, shouldRefresh } from '../../pubUtils/util';
 import { STATUS, TASK_TYPE, TASK_FUN_TYPE, SHOP_REFRESH_TYPE, WAR_TYPE } from '../../consts';
-import { TaskParam, TaskListReturn } from '../../domain/roleField/task';
+import { TaskParamInter, TaskListReturn } from '../../domain/roleField/task';
 import { EPlace, HeroType } from '../../db/Hero';
 import { getRoleOnlineInfo } from '../redisService';
 import { HeroScores } from '../../db/PvpHistoryOpp';
@@ -15,187 +14,136 @@ import { gameData } from '../../pubUtils/data';
 import { getSeconds, getZeroPointD } from '../../pubUtils/timeUtil';
 import { RoleStatus } from '../../db/ComBattleTeam';
 import { getActivities } from '../activity/activityService';
+import { CheckTask } from './taskObj';
 
-export async function checkTaskWithRoles(serverId: number, roleId: string, sid: string, taskType: number, roles: RoleType[]) {
+export async function checkTaskWithRoles(serverId: number, roleId: string, sid: string, taskType: TASK_TYPE, roles: RoleType[]) {
     for (let role of roles) {
         if (role) {
-            await checkTaskWithRole(serverId, role.roleId, role.roleId == roleId ? sid : null, taskType, role);
+            await checkTask(serverId, role.roleId, role.roleId == roleId ? sid : null, taskType, role);
         }
     }
 }
 
-export async function checkTaskWithRole(serverId: number, roleId: string, sid: string, taskType: number, role: RoleType) {
+export async function checkTaskWithRole(serverId: number, roleId: string, sid: string, taskType: TASK_TYPE, role: RoleType, args?: TaskParamInter) {
-    let pushMessage = await taskUtil.checkTaskWithRole(serverId, roleId, taskType, role);
+    let task = new CheckTask(serverId, roleId);
-    pushTaskUpdate(roleId, sid, pushMessage);
+    task.setRole(role);
+    task.setParam(taskType, args);
+    await task.saveAndPush(sid);
 }
 
-export async function checkTaskWithHero(roleId: string, sid: string, taskType: number, hero: HeroType, args?: number[]) {
+export async function checkTask(serverId: number, roleId: string, sid: string, taskType: TASK_TYPE, args?: TaskParamInter) {
-    let pushMessage = await taskUtil.checkTaskWithHero(roleId, taskType, hero, args);
+    let task = new CheckTask(serverId, roleId);
-    pushTaskUpdate(roleId, sid, pushMessage);
+    task.setParam(taskType, args);
+    await task.saveAndPush(sid);
 }
 
-export async function checkTaskWithEplaces(roleId: string, sid: string, taskType: number, eplace: EPlace[], newEplace: EPlace[], eplaceIds: number[], params?: any) {
+export async function checkTaskInEntry(serverId: number, roleId: string, sid: string, role: RoleType) {
-    let pushMessage = await taskUtil.checkTaskWithEplaces(roleId, taskType, eplace, newEplace, eplaceIds, params);
+    let task = new CheckTask(serverId, roleId);
-    pushTaskUpdate(roleId, sid, pushMessage);
+    task.setRole(role);
+    task.setParam(TASK_TYPE.LOGIN_SUM, {});
+    task.setParam(TASK_TYPE.LOGIN_SERIES, {});
+    await task.saveAndPush(sid);
 }
 
-export async function checkTaskWithEplace(roleId: string, sid: string, taskType: number, oldEquip: EPlace, newEplace: EPlace, params?: any) {
+export async function checkTaskInCreateHero(serverId: number, roleId: string, sid: string, heroNum: number, heroes: HeroType[]) {
-    let pushMessage = await taskUtil.checkTaskWithEplace(roleId, taskType, oldEquip, newEplace, params);
+    let task = new CheckTask(serverId, roleId);
-    pushTaskUpdate(roleId, sid, pushMessage);
+    task.setParam(TASK_TYPE.HERO_NUM, { heroNum });
+    task.setParam(TASK_TYPE.HERO_QUALITY, { heroes });
+    task.setParam(TASK_TYPE.HERO_QUALITY_STAR_UP, { heroes });
+    task.setParam(TASK_TYPE.HERO_LV, { heroes });
+    await task.saveAndPush(sid);
 }
 
-export async function checkTaskWithArgs(roleId: string, sid: string, taskType: number, args: number[]) {
+export async function checkTaskInHeroStarUp(serverId: number, roleId: string, sid: string, hero: HeroType, oldStar: number) {
-    let pushMessage = await taskUtil.checkTaskWithArgs(roleId, taskType, args);
+    let task = new CheckTask(serverId, roleId);
-    pushTaskUpdate(roleId, sid, pushMessage);
+    task.setParam(TASK_TYPE.HERO_STAR_UP, { hero });
+    task.setParam(TASK_TYPE.HERO_QUALITY_STAR_UP, { hero, oldStar });
+    await task.saveAndPush(sid);
 }
 
-export async function checkTaskWithWar(roleId: string, sid: string, taskType: number, warId: number, heroes: number[], count: number, star: number) {
+export async function checkTaskInHeroWakeUp(serverId: number, roleId: string, sid: string, hero: HeroType, oldColorStar: number) {
-    let pushMessage = await taskUtil.checkTaskWithWar(roleId, taskType, warId, heroes, count, star);
+    let task = new CheckTask(serverId, roleId);
-    pushTaskUpdate(roleId, sid, pushMessage);
+    task.setParam(TASK_TYPE.HERO_STAR_UP, { hero });
+    task.setParam(TASK_TYPE.HERO_WAKE_UP, { hero, oldColorStar });
+    task.setParam(TASK_TYPE.HERO_QUALITY_WAKE_UP_COUNT, { hero, oldColorStar });
+    task.setParam(TASK_TYPE.HERO_WAKE_UP_COUNT, { hero, oldColorStar });
+    task.setParam(TASK_TYPE.HERO_WAKE_UP_STAR_UP_COUNT, { hero });
+    await task.saveAndPush(sid);
 }
 
-export async function checkTaskWithGoods(roleId: string, sid: string, taskType: number, goods: ItemInter[]) {
+export async function checkTaskInHeroQUalityUp(serverId: number, roleId: string, sid: string, hero: HeroType) {
-    let pushMessage = await taskUtil.checkTaskWithGoods(roleId, taskType, goods);
+    // 任务
-    pushTaskUpdate(roleId, sid, pushMessage);
+    await checkTask(serverId, roleId, sid, TASK_TYPE.HERO_QUALITY_UP, { hero });
+    // 任务
+    await checkTask(serverId, sid, roleId, TASK_TYPE.HERO_QUALITY_TO_QUALITY_COUNT, { hero });
+
 }
 
-export async function checkTask(roleId: string, sid: string, taskType: number, count: number, isInc: boolean, param: TaskParam) {
+export async function checkTaskInHeroTrain(serverId: number, roleId: string, sid: string, hero: HeroType, trainCount: number) {
-    let pushMessage = await taskUtil.checkTask(roleId, taskType, count, isInc, param);
+    let task = new CheckTask(serverId, roleId);
-    pushTaskUpdate(roleId, sid, pushMessage);
+    task.setParam(TASK_TYPE.HERO_TRAIN, { hero, trainCount });
-}
+    task.setParam(TASK_TYPE.HERO_TRAIN_SUM, { hero, trainCount });
-
+    await task.saveAndPush(sid);
-export async function pushTaskUpdate(roleId: string, sid: string, pushMessage: TaskListReturn[]) {
-    if (pushMessage.length > 0) {
-        if (!sid) {
-            let onlineUser = await getRoleOnlineInfo(roleId);
-            sid = onlineUser.sid;
-        }
-        if (!!sid) {
-            let uids = [{ uid: roleId, sid }];
-            pinus.app.get('channelService').pushMessageByUids('onTaskUpdate', resResult(STATUS.SUCCESS, pushMessage), uids);
-        }
-    }
-}
-
-
-export async function checkActivityTask(serverId: number, sid: string, roleId: string, taskType: TASK_TYPE, count: number, parma?: any) {
-    let pushMessage = await taskUtil.accomplishTask(serverId, roleId, taskType, count, parma, await getActivities());
-    pushActivityUpdate(roleId, sid, pushMessage);
-    return pushMessage;
-}
-
-export async function pushActivityUpdate(roleId: string, sid: string, pushMessage: any[]) {
-    // console.log('pushActivityUpdate', JSON.stringify(pushMessage))
-    if (pushMessage?.length > 0) {
-        if (!sid) {
-            let onlineUser = await getRoleOnlineInfo(roleId);
-            sid = onlineUser.sid;
-        }
-        if (!!sid) {
-            let uids = [{ uid: roleId, sid }];
-            pinus.app.get('channelService').pushMessageByUids('onActivityTaskUpdate', resResult(STATUS.SUCCESS, pushMessage), uids);
-        }
-    }
 }
 
 /**
  * battle.normalBattleHandler.battleEnd 中会触发的任务，因为有点多提出来了
  */
-export async function checkTaskInBattleEnd(serverId: number, roleId: string, sid: string, battleId: number, heroes: number[], star: number) {
+ export async function checkTaskInBattleEnd(serverId: number, roleId: string, sid: string, warId: number, battleHeroes: number[], battleStar: number) {
-
+    let task = new CheckTask(serverId, roleId);
-    await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_WITH_HERO, battleId, heroes, 1, star);
+    task.setParam(TASK_TYPE.BATTLE_WITH_HERO, { warId, battleHeroes });
-    await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_MAIN, battleId, heroes, 1, star);
+    task.setParam(TASK_TYPE.BATTLE_MAIN, { warId, count: 1 });
-    await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_DAILY_STAR, battleId, heroes, 1, star);
+    task.setParam(TASK_TYPE.BATTLE_DAILY_STAR, { warId, battleStar });
-    await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_DAILY, battleId, heroes, 1, star);
+    task.setParam(TASK_TYPE.BATTLE_DAILY, { warId, count: 1 });
-    await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_DUNGEON, battleId, heroes, 1, star);
+    task.setParam(TASK_TYPE.BATTLE_DUNGEON, { warId, count: 1 });
-    await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_DUNGEON_WAR, battleId, heroes, 1, star);
+    task.setParam(TASK_TYPE.BATTLE_DUNGEON_WAR, { warId, count: 1 });
-    await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_TOWER, battleId, heroes, 1, star);
+    task.setParam(TASK_TYPE.BATTLE_TOWER, { warId, count: 1 });
-    await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_VESTIGE, battleId, heroes, 1, star);
+    task.setParam(TASK_TYPE.BATTLE_VESTIGE, { warId, count: 1 });
-    await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_EXPEDITION, battleId, heroes, 1, star);
+    task.setParam(TASK_TYPE.BATTLE_EXPEDITION, { warId, count: 1 });
-    //成长任务
+    await task.saveAndPush(sid);
-    let dicWar = gameData.war.get(battleId);
-    if (dicWar) {
-        if (dicWar.warType == WAR_TYPE.NORMAL) {
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.BATTLE_MAIN, 1, { warId: battleId })
-        } else if (dicWar.warType == WAR_TYPE.EXPEDITION) {
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.BATTLE_EXPEDITION, 1)
-        } else if (dicWar.warType == WAR_TYPE.MYSTERY || dicWar.warType == WAR_TYPE.MYSTERY_ELITE) {
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.BATTLE_DUNGEON, 1)
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.BATTLE_DUNGEON_WAR, 1, { warId: battleId })
-        } else if (dicWar.warType == WAR_TYPE.TOWER) {
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.BATTLE_TOWER, 1)
-        } else if (dicWar.warType == WAR_TYPE.DAILY) {
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.BATTLE_DAILY, 1, { dailyType: dicWar.dailyType })
-        }
-    }
-
 }
 
-export async function checkTaskInBattleSweep(serverId: number, roleId: string, sid: string, battleId: number, count: number) {
 
-    // 任务
+export async function checkTaskInBattleSweep(serverId: number, roleId: string, sid: string, warId: number, count: number) {
-    await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_MAIN_SWEEP, battleId, [], count, 0);
+    let task = new CheckTask(serverId, roleId);
-    //活动任务
+    task.setParam(TASK_TYPE.BATTLE_MAIN_SWEEP, { warId, count });
-    await checkActivityTask(serverId, sid, roleId, TASK_TYPE.BATTLE_MAIN_SWEEP, count, { battleId })
+    task.setParam(TASK_TYPE.BATTLE_MAIN, { warId, count });
-
+    task.setParam(TASK_TYPE.BATTLE_DAILY, { warId, count });
-    await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_MAIN, battleId, [], count, 0);
+    task.setParam(TASK_TYPE.BATTLE_DUNGEON, { warId, count });
-    await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_DAILY_STAR, battleId, [], count, 0);
+    task.setParam(TASK_TYPE.BATTLE_DUNGEON_WAR, { warId, count });
-    await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_DAILY, battleId, [], count, 0);
+    task.setParam(TASK_TYPE.BATTLE_TOWER, { warId, count });
-    await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_DUNGEON, battleId, [], count, 0);
+    task.setParam(TASK_TYPE.BATTLE_VESTIGE, { warId, count });
-    await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_DUNGEON_WAR, battleId, [], count, 0);
+    task.setParam(TASK_TYPE.BATTLE_EXPEDITION, { warId, count });
-    await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_TOWER, battleId, [], count, 0);
+    await task.saveAndPush(sid);
-    await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_VESTIGE, battleId, [], count, 0);
-    await checkTaskWithWar(roleId, sid, TASK_TYPE.BATTLE_EXPEDITION, battleId, [], count, 0);
-    //成长任务
-    let dicWar = gameData.war.get(battleId);
-    if (dicWar) {
-        if (dicWar.warType == WAR_TYPE.NORMAL) {
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.BATTLE_MAIN, count, { warId: battleId })
-        } else if (dicWar.warType == WAR_TYPE.EXPEDITION) {
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.BATTLE_EXPEDITION, count)
-        } else if (dicWar.warType == WAR_TYPE.MYSTERY || dicWar.warType == WAR_TYPE.MYSTERY_ELITE) {
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.BATTLE_DUNGEON, count)
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.BATTLE_DUNGEON_WAR, count, { warId: battleId })
-        } else if (dicWar.warType == WAR_TYPE.TOWER) {
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.BATTLE_TOWER, count)
-        } else if (dicWar.warType == WAR_TYPE.DAILY) {
-            await checkActivityTask(serverId, sid, roleId, TASK_TYPE.BATTLE_DAILY, count, { dailyType: dicWar.dailyType })
-        }
-    }
 }
 
+
 export async function checkTaskInComBattleStart(roleStatus: RoleStatus[], capId: string) {
     // console.log('********', JSON.stringify(roleStatus), capId, quality)
     for (let { roleId, isRobot } of roleStatus) {
         if (!isRobot) {
-
+            let role = await RoleModel.findByRoleId(roleId);
-            let { serverId } = await RoleModel.findByRoleId(roleId);
 
             if (roleId == capId && roleStatus.length > 1) {  // 招募队友
-                await checkTask(roleId, null, TASK_TYPE.COM_BATTLE_CREATE_TEAM, 1, true, {});
+                await checkTaskWithRole(role.serverId, roleId, null, TASK_TYPE.COM_BATTLE_CREATE_TEAM, role);
             } else if (roleId !== capId) { // 协助寻宝
-                await checkTask(roleId, null, TASK_TYPE.COM_BATTLE_ASSIST_TEAM, 1, true, {});
+                await checkTaskWithRole(role.serverId, roleId, null, TASK_TYPE.COM_BATTLE_ASSIST_TEAM, role);
-                //活动任务
-                await checkActivityTask(serverId, null, roleId, TASK_TYPE.COM_BATTLE_ASSIST_TEAM, 1);
             }
-            await checkTask(roleId, null, TASK_TYPE.COM_BATTLE, 1, true, {});
+            await checkTaskWithRole(role.serverId, roleId, null, TASK_TYPE.COM_BATTLE, role);
-            //活动任务
-            await checkActivityTask(serverId, null, roleId, TASK_TYPE.COM_BATTLE, 1);
         }
     }
 }
 
-export async function checkTaskInPvpEnd(roleId: string, sid: string, isSuccess: boolean, heroScores: HeroScores[]) {
+export async function checkTaskInPvpEnd(serverId: number, roleId: string, sid: string, isSuccess: boolean, heroScores: HeroScores[]) {
-    if (isSuccess) {
+    await checkTask(serverId, roleId, sid, TASK_TYPE.PVP_WIN, { isSuccess })
-        await checkTask(roleId, sid, TASK_TYPE.PVP_WIN, 1, true, {});
+    await checkTask(serverId, roleId, sid, TASK_TYPE.PVP_WIN_SERIES, { isSuccess });
-        await checkTask(roleId, sid, TASK_TYPE.PVP_WIN_SERIES, 1, true, {});
+    await checkTask(serverId, roleId, sid, TASK_TYPE.PVP_HERO_SCORE, { heroScores });
-    } else {
-        await checkTask(roleId, sid, TASK_TYPE.PVP_WIN_SERIES, 0, false, {});
-    }
-
-    await checkTask(roleId, sid, TASK_TYPE.PVP_HERO_SCORE, 0, false, { heroScores });
 }
 
+export async function checkTaskInGacha(serverId: number, roleId: string, sid: string, count: number, heroes: HeroType[]) {
+    await checkTask(serverId, roleId, sid, TASK_TYPE.GACHA, { count });
+    await checkTask(serverId, roleId, sid, TASK_TYPE.GACHA_QUALITY_COUNT, { heroes });
+}
 
 // 获取task状态
 export async function getCurTask(roleId: string, session: FrontendOrBackendSession) {

shared/consts/constModules/sysConst.ts

@@ -211,7 +211,7 @@ export enum REDIS_KEY {
     PVP_RANK ="pvpRank", // pvp排行榜
     GUILD_INFO ="guildInfo", // 公会信息
     GUILD_ACTIVE_RANK ="guildActiveRank", // 公会周活跃排行榜
-    DB_GAME ='dbGame',                // 服务器列表
+    SERVER ='server',                // 服务器列表
     ONLINE_USERS ='onlineUsers',        // 在线用户情况
     ONLINE_TIME ='onlineTime',          // 玩家在线时间
     CHANNEL_SERVERS ='chat:channelServers',        // 渠道对应的 chat 服务器 Id,
@@ -634,7 +634,7 @@ export enum TASK_TYPE {
     LOGIN_SUM = 1,                    // 累计登录
     LOGIN_SERIES = 2,                 // 连续登录
     ROLE_LV = 3,                      // 主公等级
-    GASHA = 4,                        // 招募
+    GACHA = 4,                        // 招募
     HERO_NUM = 5,                     // 武将数量
     HERO_STAR_UP = 6,                 // 升星次数
     HERO_QUALITY = 7,                 // 拥有品质

shared/db/ActivityDailyChallenges.ts

@@ -37,44 +37,25 @@ export default class Activity_Daily_Challenges extends BaseModel {
     }
 
     // 更新任务
-    public static async checkAndUpdateTask(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, param: UpdateTaskParam) {
-        let canSet = true;
-        if(param.record || param.max || param.min) {
-            let rec = await this.findDataByCellIndex(serverId, activityId, roleId, dayIndex, cellIndex);
-            if(rec) {
-                if(param.record && rec.records.indexOf(param.record) != -1) {
-                    canSet = false;
-                } else if (param.max && rec.totalCount >= param.max) {
-                    canSet = false;
-                } else if (param.min && rec.totalCount <= param.min) {
-                    canSet = false;
-                }
-            }
-        }
-        if(canSet) {
-            return await this.setOrIncTask(serverId, activityId, roleId, dayIndex, cellIndex, param);
-        }
-    }
-
     public static async setOrIncTask(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, param: UpdateTaskParam) {
         if(param.set) {
-            return await this.setTaskCount(serverId, activityId, roleId, dayIndex, cellIndex, param.set, param.record);
+            return await this.setTaskCount(serverId, activityId, roleId, dayIndex, cellIndex, param.set, param.records);
         } else if (param.inc) {
-            return await this.addTaskCount(serverId, activityId, roleId, dayIndex, cellIndex, param.inc, param.record);
+            return await this.addTaskCount(serverId, activityId, roleId, dayIndex, cellIndex, param.inc, param.records);
         }
     }
 
     //根据活动统计完成任务次数
-    public static async setTaskCount(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, count: number, record?: string) {
+    public static async setTaskCount(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, count: number, records?: string[]) {
         let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex },
-            { $set: { totalCount: count }, $addToSet: { records: record||''} }, { upsert: true, new: true }).lean();
+            { $set: { totalCount: count, records } }, { upsert: true, new: true }).lean();
         return result;
     }
 
     //根据活动统计完成任务次数
-    public static async addTaskCount(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, addCount: number, record?: string) {
+    public static async addTaskCount(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, addCount: number, records?: string[]) {
         let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex },
-            { $inc: { totalCount: addCount }, $addToSet: { records: record||''} }, { upsert: true, new: true }).lean();
+            { $inc: { totalCount: addCount }, $set: { records: records||[]} }, { upsert: true, new: true }).lean();
         return result;
     }
 

shared/db/ActivityGrowth.ts

@@ -36,45 +36,25 @@ export default class Activity_Growth extends BaseModel {
         return result;
     }
 
-    // 更新任务
-    public static async checkAndUpdateTask(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, param: UpdateTaskParam) {
-        let canSet = true;
-        if(param.record || param.max || param.min) {
-            let rec = await this.findDataByCellIndex(serverId, activityId, roleId, dayIndex, cellIndex);
-            if(rec) {
-                if(param.record && rec.records.indexOf(param.record) != -1) {
-                    canSet = false;
-                } else if (param.max && rec.totalCount >= param.max) {
-                    canSet = false;
-                } else if (param.min && rec.totalCount <= param.min) {
-                    canSet = false;
-                }
-            }
-        }
-        if(canSet) {
-            return await this.setOrIncTask(serverId, activityId, roleId, dayIndex, cellIndex, param);
-        }
-    }
-
     public static async setOrIncTask(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, param: UpdateTaskParam) {
         if(param.set) {
-            return await this.setTaskCount(serverId, activityId, roleId, dayIndex, cellIndex, param.set, param.record);
+            return await this.setTaskCount(serverId, activityId, roleId, dayIndex, cellIndex, param.set, param.records);
         } else if (param.inc) {
-            return await this.addTaskCount(serverId, activityId, roleId, dayIndex, cellIndex, param.inc, param.record);
+            return await this.addTaskCount(serverId, activityId, roleId, dayIndex, cellIndex, param.inc, param.records);
         }
     }
 
     //根据活动统计完成任务次数
-    public static async setTaskCount(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, count: number, record?: string) {
+    public static async setTaskCount(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, count: number, records?: string[]) {
         let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex },
-            { $set: { totalCount: count }, $addToSet: { records: record||'' } }, { upsert: true, new: true }).lean();
+            { $set: { totalCount: count, records: records||[] } }, { upsert: true, new: true }).lean();
         return result;
     }
 
     //根据活动统计完成任务次数
-    public static async addTaskCount(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, addCount: number, record?: string) {
+    public static async addTaskCount(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, addCount: number, records?: string[]) {
         let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex },
-            { $inc: { totalCount: addCount }, $addToSet: { records: record||'' } }, { upsert: true, new: true }).lean();
+            { $inc: { totalCount: addCount }, $set: { records: records||[] } }, { upsert: true, new: true }).lean();
         return result;
     }
 

shared/db/ActivityRefreshTask.ts

@@ -40,45 +40,26 @@ export default class Activity_Refresh_Task extends BaseModel {
 
 
     // 更新任务
-    public static async checkAndUpdateTask(serverId: number, activityId: number, roleId: string, roundIndex: number, pageIndex: number, id: number, param: UpdateTaskParam) {
-        let canSet = true;
-        if(param.record || param.max || param.min) {
-            let rec = await this.findDataById(serverId, activityId, roleId, roundIndex, pageIndex, id);
-            if(rec) {
-                if(param.record && rec.records.indexOf(param.record) != -1) {
-                    canSet = false;
-                } else if (param.max && rec.totalCount >= param.max) {
-                    canSet = false;
-                } else if (param.min && rec.totalCount <= param.min) {
-                    canSet = false;
-                }
-            }
-        }
-        if(canSet) {
-            return await this.setOrIncTask(serverId, activityId, roleId, roundIndex, pageIndex, id, param);
-        }
-    }
-
     public static async setOrIncTask(serverId: number, activityId: number, roleId: string, roundIndex: number, pageIndex: number, id: number, param: UpdateTaskParam) {
         if(param.set) {
-            return await this.setTaskCount(serverId, activityId, roleId, roundIndex, pageIndex, id, param.set, param.record);
+            return await this.setTaskCount(serverId, activityId, roleId, roundIndex, pageIndex, id, param.set, param.records);
         } else if (param.inc) {
-            return await this.addTaskCount(serverId, activityId, roleId, roundIndex, pageIndex, id, param.inc, param.record);
+            return await this.addTaskCount(serverId, activityId, roleId, roundIndex, pageIndex, id, param.inc, param.records);
         }
     }
 
 
     //根据活动统计完成任务次数
-    public static async setTaskCount(serverId: number, activityId: number, roleId: string, roundIndex: number, pageIndex: number, id: number, count: number, record?: string) {
+    public static async setTaskCount(serverId: number, activityId: number, roleId: string, roundIndex: number, pageIndex: number, id: number, count: number, records?: string[]) {
         let result: ActivityRefreshTaskModelType = await ActivityRefreshTaskModel.findOneAndUpdate({ serverId, roleId, activityId, roundIndex, pageIndex, id },
-            { $set: { totalCount: count }, $setOnInsert: { records: record||'' } }, { upsert: true, new: true }).lean();
+            { $set: { totalCount: count, records: records||[] }}, { upsert: true, new: true }).lean();
         return result;
     }
 
     //根据活动统计完成任务次数
-    public static async addTaskCount(serverId: number, activityId: number, roleId: string, roundIndex: number, pageIndex: number, id: number, count: number, record?: string) {
+    public static async addTaskCount(serverId: number, activityId: number, roleId: string, roundIndex: number, pageIndex: number, id: number, count: number, records?: string[]) {
         let result: ActivityRefreshTaskModelType = await ActivityRefreshTaskModel.findOneAndUpdate({ serverId, roleId, activityId, roundIndex, pageIndex, id },
-            { $inc: { totalCount: count }, $setOnInsert: { records: record||'' } }, { upsert: true, new: true }).lean();
+            { $inc: { totalCount: count }, $set: { records: records||[] } }, { upsert: true, new: true }).lean();
         return result;
     }
 

shared/db/ActivityThirtyDays.ts

@@ -66,30 +66,11 @@ export default class Activity_Thirty_Days extends BaseModel {
 
 
     // 更新任务
-    public static async checkAndUpdateTask(serverId: number, activityId: number, roleId: string, pageIndex: number, cellIndex: number, tab: number, param: UpdateTaskParam) {
-        let canSet = true;
-        if(param.record || param.max || param.min) {
-            let rec = await this.findDataByCellIndex(serverId, activityId, roleId, pageIndex, cellIndex, tab);
-            if(rec) {
-                if(param.record && rec.records.indexOf(param.record) != -1) {
-                    canSet = false;
-                } else if (param.max && rec.totalCount >= param.max) {
-                    canSet = false;
-                } else if (param.min && rec.totalCount <= param.min) {
-                    canSet = false;
-                }
-            }
-        }
-        if(canSet) {
-            return await this.setOrIncTask(serverId, activityId, roleId, pageIndex, cellIndex, tab, param);
-        }
-    }
-
     public static async setOrIncTask(serverId: number, activityId: number, roleId: string, pageIndex: number, cellIndex: number, tab: number, param: UpdateTaskParam) {
         if(param.set) {
-            return await this.setTaskCount(serverId, activityId, roleId, pageIndex, cellIndex, tab, param.set, param.record);
+            return await this.setTaskCount(serverId, activityId, roleId, pageIndex, cellIndex, tab, param.set, param.records);
         } else if (param.inc) {
-            return await this.addTaskCount(serverId, activityId, roleId, pageIndex, cellIndex, tab, param.inc, param.record);
+            return await this.addTaskCount(serverId, activityId, roleId, pageIndex, cellIndex, tab, param.inc, param.records);
         }
     }
 
@@ -102,16 +83,16 @@ export default class Activity_Thirty_Days extends BaseModel {
     }
 
     //根据活动统计完成任务次数
-    public static async addTaskCount(serverId: number, activityId: number, roleId: string, pageIndex: number, cellIndex: number, tab: number, count: number, record?: string) {
+    public static async addTaskCount(serverId: number, activityId: number, roleId: string, pageIndex: number, cellIndex: number, tab: number, count: number, records?: string[]) {
         let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOneAndUpdate({ serverId, roleId, activityId, pageIndex, cellIndex, tab },
-            { $inc: { totalCount: count }, $addToSet: { records: record||'' } }, { upsert: true, new: true }).lean();
+            { $inc: { totalCount: count }, $set: { records: records||[] } }, { upsert: true, new: true }).lean();
         return result;
     }
 
     //根据活动统计完成任务次数
-    public static async setTaskCount(serverId: number, activityId: number, roleId: string, pageIndex: number, cellIndex: number, tab: number, count: number, record?: string) {
+    public static async setTaskCount(serverId: number, activityId: number, roleId: string, pageIndex: number, cellIndex: number, tab: number, count: number, records?: string[]) {
         let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOneAndUpdate({ serverId, roleId, activityId, pageIndex, cellIndex, tab },
-            { $set: { totalCount: count }, $addToSet: { records: record||'' } }, { upsert: true, new: true }).lean();
+            { $set: { totalCount: count, records: records||[] } }, { upsert: true, new: true }).lean();
         return result;
     }
 }

shared/db/ActivityTreasureHuntTask.ts

@@ -29,44 +29,25 @@ export default class Activity_Treasure_Hunt_Task extends ActivityGrowth {
     }
 
     // 更新任务
-    public static async checkAndUpdateTask(serverId: number, activityId: number, roleId: string, roundIndex: number, cellIndex: number, param: UpdateTaskParam) {
-        let canSet = true;
-        if(param.record || param.max || param.min) {
-            let rec = await this.findDataByCellIndex(serverId, activityId, roleId, roundIndex, cellIndex);
-            if(rec) {
-                if(param.record && rec.records.indexOf(param.record) != -1) {
-                    canSet = false;
-                } else if (param.max && rec.totalCount >= param.max) {
-                    canSet = false;
-                } else if (param.min && rec.totalCount <= param.min) {
-                    canSet = false;
-                }
-            }
-        }
-        if(canSet) {
-            return await this.setOrIncTask(serverId, activityId, roleId, roundIndex, cellIndex, param);
-        }
-    }
-
     public static async setOrIncTask(serverId: number, activityId: number, roleId: string, roundIndex: number, cellIndex: number, param: UpdateTaskParam) {
         if(param.set) {
-            return await this.setTaskCount(serverId, activityId, roleId, roundIndex, cellIndex, param.set, param.record);
+            return await this.setTaskCount(serverId, activityId, roleId, roundIndex, cellIndex, param.set, param.records);
         } else if (param.inc) {
-            return await this.addTaskCount(serverId, activityId, roleId, roundIndex, cellIndex, param.inc, param.record);
+            return await this.addTaskCount(serverId, activityId, roleId, roundIndex, cellIndex, param.inc, param.records);
         }
     }
 
     //根据活动统计完成任务次数
-    public static async setTaskCount(serverId: number, activityId: number, roleId: string, roundIndex: number, cellIndex: number, count: number, record?: string) {
+    public static async setTaskCount(serverId: number, activityId: number, roleId: string, roundIndex: number, cellIndex: number, count: number, records?: string[]) {
         let result: ActivityTreasureHuntTaskModelType = await ActivityTreasureHuntTaskModel.findOneAndUpdate({ serverId, roleId, activityId, roundIndex, cellIndex },
-            { $set: { totalCount: count }, $addToSet: { records: record||'' } }, { upsert: true, new: true }).lean();
+            { $set: { totalCount: count, records: records||[] } }, { upsert: true, new: true }).lean();
         return result;
     }
 
     //根据活动统计完成任务次数
-    public static async addTaskCount(serverId: number, activityId: number, roleId: string, roundIndex: number, cellIndex: number, count: number, record?: string) {
+    public static async addTaskCount(serverId: number, activityId: number, roleId: string, roundIndex: number, cellIndex: number, count: number, records?: string[]) {
         let result: ActivityTreasureHuntTaskModelType = await ActivityTreasureHuntTaskModel.findOneAndUpdate({ serverId, roleId, activityId, roundIndex, cellIndex },
-            { $inc: { totalCount: count }, $addToSet: { records: record||'' } }, { upsert: true, new: true }).lean();
+            { $inc: { totalCount: count }, $set: { records: records||[] } }, { upsert: true, new: true }).lean();
         return result;
     }
 

shared/db/UserTaskRec.ts

@@ -47,51 +47,23 @@ export default class UserTaskRec extends BaseModel {
         }
     }
 
-    public static async setTaskRec(roleId: string, type: number, taskType: number, group: string, count: number, record?: string) {
+    public static async setTaskRec(roleId: string, type: number, taskType: number, group: string, count: number, records?: string[]) {
         let condition = this.getRefreshCondition(type);
-        let rec: UserTaskRecType = await UserTaskRecModel.findOneAndUpdate({ roleId, group, taskType, ...condition }, { $setOnInsert: { code: genCode(8), received: [] }, $set: { count }, $addToSet: { records: record||'' } }, { new: true, upsert: true }).lean();
+        let rec: UserTaskRecType = await UserTaskRecModel.findOneAndUpdate({ roleId, group, taskType, ...condition }, { $setOnInsert: { code: genCode(8), received: [] }, $set: { count, records: records||[] } }, { new: true, upsert: true }).lean();
         return rec;
     }
 
-    public static async incTaskRec(roleId: string, type: number, taskType: number, group: string, count: number,  record?: string) {
+    public static async incTaskRec(roleId: string, type: number, taskType: number, group: string, count: number,  records?: string[]) {
         let condition = this.getRefreshCondition(type);
-        let rec: UserTaskRecType = await UserTaskRecModel.findOneAndUpdate({ roleId, group, taskType, ...condition }, { $setOnInsert: { code: genCode(8), received: [] }, $inc: { count }, $addToSet: { records: record||'' } }, { new: true, upsert: true }).lean();
+        let rec: UserTaskRecType = await UserTaskRecModel.findOneAndUpdate({ roleId, group, taskType, ...condition }, { $setOnInsert: { code: genCode(8), received: [] }, $inc: { count }, $set: { records: records||[] } }, { new: true, upsert: true }).lean();
         return rec;
     }
 
-    /**
-     * 检查是否可以更新任务并更新
-     * @param roleId 玩家id
-     * @param type 任务大类型，日常、成就、每日
-     * @param taskType 任务类型
-     * @param group 活动组
-     * @param param 更新参数
-     * @returns 
-     */
-    public static async checkAndUpdateTask(roleId: string, type: TASK_FUN_TYPE, taskType: number, group: string, param: UpdateTaskParam) {
-        let canSet = true;
-        if(param.record || param.max || param.min) {
-            let rec = await this.findByRoleAndGroup(roleId, type, taskType, group);
-            if(rec) {
-                if(param.record && rec.records.indexOf(param.record) != -1) {
-                    canSet = false;
-                } else if (param.max && rec.count >= param.max) {
-                    canSet = false;
-                } else if (param.min && rec.count <= param.min) {
-                    canSet = false;
-                }
-            }
-        }
-        if(canSet) {
-            return await this.setOrIncTask(roleId, type, taskType, group, param);
-        }
-    }
-
     public static async setOrIncTask(roleId: string, type: number, taskType: number, group: string, param: UpdateTaskParam) {
         if(param.set) {
-            return await this.setTaskRec(roleId, type, taskType, group, param.set, param.record);
+            return await this.setTaskRec(roleId, type, taskType, group, param.set, param.records);
         } else if (param.inc) {
-            return await this.incTaskRec(roleId, type, taskType, group, param.inc, param.record);
+            return await this.incTaskRec(roleId, type, taskType, group, param.inc, param.records);
         }
     }
 

shared/domain/roleField/task.ts

@@ -1,38 +1,43 @@
-import { HeroScore } from "../../domain/battleField/pvp";
+import { HeroType } from "../../db/Hero";
+import { HeroScore } from "../battleField/pvp";
+
+export class TaskParamInter {
+    hero?: HeroType;          // 武将数据
+    heroes?: HeroType[];      // 很多武将数据
+    count?: number;           // 抽卡的次数
+
+    warId?: number;           // 当前关卡id
+    towerLv?: number;         // 镇念塔层数
+    lv?: number;              // 现玩家等级
+    chatType?: number;        // 聊天：聊天类型
+    battleHeroes?: number[];  // 战斗时候使用的
+    battleStar?: number;      // 战斗结算时候的星级
+    heroNum?: number;         // 武将数量
+    trainCount?: number;      // 武将训练次数
+    stageUpCnt?: number;      // 武将升阶次数
+    connectLv?: number;       // 羁绊等级
+    isSuccess?: boolean;      // pvp是否胜利
+    heroScores?: HeroScore[]; // pvp各武将积分
+
+    oldLv?: number;           // 原武将等级，原玩家等级
+    oldStar?: number;         // 原武将星级
+    oldColorStar?: number;    // 原武将彩星
+    oldJob?: number;          // 原武将职业
+    oldJobStage?: number;     // 原武将职业阶
+    oldFavourLv?: number;     // 原好感度等级
+};
+
+export class TaskParam extends TaskParamInter {
+
+    public setParam(params: TaskParamInter) {
+        for(let key in params) {
+            this[key] = params[key];
+        } 
+    }
 
-export class TaskParam {
-    star?: number;
-    quality?: number;
-    lv?: number;
-    count?: number;
-    favourLv?: number;
-    connectLv?: number;
-    isPutOn?: number;
-    oldLv?: number;
-    stage?: number;
-    chatType?: number;
-    warId?: number;
-    heroes?: number[];
-    eventType?: number;
-    dailyType?: number;
-    point?: number;
-    gid?: number;
-    heroScores?: HeroScore[];
-    rankLv?: number;
-    title?: number;
-    oldTitle?: number;
-    job?: number;
-    aid?: number;
-    isDebug?: boolean;
-    oldCount?: number;
-    oldStar?: number;
-    hid?: number;
-    eplaceId?: number;
-    oldQuality?: number;
-    oldStoneLvs?: number[];
-    newStoneLvs?: number[];
 }
 
+
 export class TaskListReturn {
     type: number;      // 类型
     id: number;        // 任务id
@@ -43,7 +48,5 @@ export class TaskListReturn {
 export interface UpdateTaskParam {
     inc?: number;        // 直接增
     set?: number;        // 直接设
-    record?: string;     // 检查是否有这条记录、没有的话增
+    records?: string[];     // 检查是否有这条记录、没有的话增
-    max?: number;        // 检查是否是最大的，不是的话更
-    min?: number;        // 检查是否是最小的，不是的话更
 }

web-server/app/service/Auth.ts

@@ -1,5 +1,5 @@
 
-import { COUNTER, DEFAULT_LV, ADULT_AGE, GUEST_MAX_TIME, TASK_TYPE, BLOCK_TYPE, TA_EVENT } from '@consts';
+import { COUNTER, DEFAULT_LV, ADULT_AGE, GUEST_MAX_TIME, BLOCK_TYPE, TA_EVENT } from '@consts';
 import { RoleModel } from '@db/Role';
 import { UserModel, UserType } from '@db/User';
 import { STATUS, GET_SMS_TYPE, ADDICTION_PREVENTION_CODE } from '@consts';
@@ -12,7 +12,6 @@ import { getAge, nowSeconds } from '../pubUtils/timeUtil';
 import { resResult } from '../pubUtils/util';
 import { checkTeeanAgerTime } from '../pubUtils/authenticateUtil';
 // import { authenticate } from '../pubUtils/httpUtil';
-import { checkTask } from 'app/pubUtils/taskUtil';
 import { getChannelId, loginValidata } from '../pubUtils/sdkUtil';
 import { LoginValidateData37 } from 'app/domain/sdk';
 import { ServerlistModel } from '@db/Serverlist';
@@ -322,7 +321,6 @@ export default class Auth extends Service {
         if (role) {
             await ServerlistModel.incRoleCnt(serverId);
             // 任务
-            await checkTask(roleId, TASK_TYPE.ROLE_LV, role.lv, false, {});
 
             ctx.service.sdk.reportTAEventWithRoleIdAndDistinctId(roleId, distinctId, TA_EVENT.CREATE_ROLE, null, ctx.clientIp);
             return ctx.service.utils.resResult(STATUS.SUCCESS, { roleId: role.roleId });