活动：修改活动bug

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

@@ -1,6 +1,6 @@
 import { Application, BackendSession } from 'pinus';
 import { resResult } from '../../../pubUtils/util';
-import { ACTIVITY_TYPE, FIRST_GIFT_STATE, SERVER_OPEN_TIME, STATUS } from '../../../consts';
+import { ACTIVITY_TYPE, FIRST_GIFT_STATE, SERVER_OPEN_TIME, STATUS, TASK_TYPE } from '../../../consts';
 import { firstGiftActivity, getPlayerFirstGiftData } from '../../../services/firstGiftService';
 import { signInActivity, signInVIPActivity } from '../../../services/signInService';
 import { growthFundActivity } from '../../../services/growthFundService';
@@ -12,6 +12,9 @@ import { yuanbaoActivity } from '../../../services/yuanbaoService';
 import { monthlyTicketActivity } from '../../../services/monthlyTicketService';
 import { rechargeMoneyActivity } from '../../../services/rechargeMoneyService';
 import moment = require('moment');
+import { RoleModel } from '../../../db/Role';
+// import { ActivityDailyChallengesModel } from '../../../db/ActivityDailyChallenges';
+// import { isComplete } from '../../../pubUtils/taskUtil';
 
 export default function (app: Application) {
     return new ActivityHandler(app);
@@ -28,8 +31,8 @@ export class ActivityHandler {
     * @param {BackendSession} session
     * @memberof ActivityHandler
     */
-    async getAllOpenActivity(msg: {}, session: BackendSession) {
+    async getAllOpenActivity(msg: { hid: number, lv: number }, session: BackendSession) {
-        const { } = msg;
+        const { hid, lv } = msg;
         const roleId = session.get('roleId');
         const serverId = session.get('serverId');
 
@@ -69,6 +72,41 @@ export class ActivityHandler {
                 });
             }
         }
+        //14天乐活动-成长任务 1 2 3
+        {
+            let sevenData = [];
+            let growthData = await growthActivity(serverId, roleId);
+            if (growthData) {
+                sevenData.push({
+                    type: ACTIVITY_TYPE.TASK_GROWTH,
+                    activityId: growthData.activityId,
+                    data: growthData,
+                });
+            }
+            let dailyChallengesData = await dailyChallengesActivity(serverId, roleId);
+            if (dailyChallengesData) {
+                sevenData.push({
+                    type: ACTIVITY_TYPE.TASK_DAILY_CHALLENGES,
+                    activityId: dailyChallengesData.activityId,
+                    data: dailyChallengesData,
+                });
+            }
+            let dailyGiftsData = await dailyGiftsActivity(serverId, roleId);
+            if (dailyGiftsData) {
+                sevenData.push({
+                    type: ACTIVITY_TYPE.DAILY_DISCOUNT_GIFT,
+                    activityId: dailyGiftsData.activityId,
+                    data: dailyGiftsData,
+                });
+            }
+            if (sevenData.length > 0) {
+                playerActivityArray.push({
+                    type: ACTIVITY_TYPE.FOURTEEN_DAY,
+                    activityId: 0,
+                    data: sevenData,
+                });
+            }
+        }
         //签到 4
         {
             let data = await signInActivity(serverId, roleId);
@@ -174,7 +212,9 @@ export class ActivityHandler {
 
         //新手限定RMB购买礼包 15
         {
-            let endTime = moment(SERVER_OPEN_TIME).startOf('d').add(7, 'd').add(5, 'h').toDate();
+            let { createTime } = await RoleModel.findByRoleId(roleId);
+            let createDate = moment(createTime * 1000).toDate();
+            let endTime = moment(createDate).startOf('d').add(7, 'd').add(5, 'h').toDate();
             if (new Date() <= endTime) {
                 let data = await newPlayerLimitPackageActivity(serverId, roleId);
                 if (data) {

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

@@ -1,10 +1,11 @@
 import { Application, BackendSession } from 'pinus';
-import { resResult } from '../../../pubUtils/util';
+import { deltaDays, resResult } from '../../../pubUtils/util';
 import { ACTIVITY_TYPE, FIRST_GIFT_STATE, SERVER_OPEN_TIME, STATUS } from '../../../consts';
 import { newPlayerLimitPackageActivity, getPlayerLimitPackageData, limitPackageActivity } from '../../../services/limitPackageService';
 import { addReward, stringToRewardParam, useGiftPackage } from '../../../services/giftPackageService';
 import { ActivityShopModel } from '../../../db/ActivityShop';
 import moment = require('moment');
+import { RoleModel } from '../../../db/Role';
 
 export default function (app: Application) {
     return new LimitPackageHandler(app);
@@ -27,7 +28,10 @@ export class LimitPackageHandler {
         const roleId = session.get('roleId');
         const serverId = session.get('serverId');
 
-        let endTime = moment(SERVER_OPEN_TIME).startOf('d').add(7, 'd').add(5, 'h').toDate();
+
+        let { createTime } = await RoleModel.findByRoleId(roleId);
+        let createDate = moment(createTime * 1000).toDate();
+        let endTime = moment(createDate).startOf('d').add(7, 'd').add(5, 'h').toDate();
         if (new Date() > endTime) {
             return resResult(STATUS.ACTIVITY_NEW_PLAYER_GIFT_END);
         }
@@ -85,7 +89,9 @@ export class LimitPackageHandler {
         switch (playerData.type) {
             case ACTIVITY_TYPE.NEW_PLAYER_LIMIT_PACKAGE:
                 {
-                    let endTime = moment(SERVER_OPEN_TIME).startOf('d').add(7, 'd').toDate();
+                    let { createTime } = await RoleModel.findByRoleId(roleId);
+                    let createDate = moment(createTime * 1000).toDate();
+                    let endTime = moment(createDate).startOf('d').add(7, 'd').toDate();
                     if (new Date() > endTime) {
                         return resResult(STATUS.ACTIVITY_NEW_PLAYER_LIMIT_PACKAGE_END);
                     }

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

@@ -71,6 +71,10 @@ export class RechargeMoneyHandler {
             await ActivityRechargeMoneyModel.setEndState(serverId, roleId, _ids);
         }
 
-        return resResult(STATUS.SUCCESS, result);
+        item.rewardTime = new Date();
+        return resResult(STATUS.SUCCESS, Object.assign(result, {
+            param: { activityId },
+            item: item
+        }));
     }
 }

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

@@ -19,7 +19,7 @@ import { gameData } from '../../../pubUtils/data';
 import { pushMysteryFirstMsg, pushTowerMsg, pushVestigeFirstMsg } from '../../../services/chatService';
 import { nowSeconds } from '../../../pubUtils/timeUtil';
 import { Rank } from '../../../services/rankService';
-import { checkTaskWithWar, checkTaskInBattleEnd } from '../../../services/taskService';
+import { checkTaskWithWar, checkTaskInBattleEnd, checkActivityTask } from '../../../services/taskService';
 
 export default function (app: Application) {
     return new NormalBattleHandler(app);
@@ -235,6 +235,7 @@ export class NormalBattleHandler {
             if (role) {
                 let r = new Rank(REDIS_KEY.MAIN_ELITE_RANK, { serverId });
                 await r.setRankWithRoleInfo(roleId, role.mainEliteWarId, role.mainEliteUpdatedAt, role);
+                await checkActivityTask(serverId, sid, funcs, roleId, TASK_TYPE.BATTLE_MAIN_ELITE, 1, { mainEliteWarId: battleId })
             }
         }
 

game-server/app/services/battleService.ts

@@ -11,7 +11,7 @@ import { HangUpSpdUpRecModel } from '../db/HangUpSpdUpRec';
 import { TowerTaskRecModel } from '../db/TowerTaskRec';
 import { cloneDeep } from 'lodash';
 import { Rank } from './rankService';
-import { checkTask } from './taskService';
+import { checkActivityTask, checkTask } from './taskService';
 import { getRandExpedition, gameData } from '../pubUtils/data';
 import { ItemInter, RewardInter } from '../pubUtils/interface';
 import { getTimeFunM } from '../pubUtils/timeUtil';
@@ -30,7 +30,7 @@ export async function checkTowerWar(roleId: string, battleId: number, heroes: Ar
     }
 
     const tower = await TowerRecordModel.getRecordByLv(roleId, towerLv);
-    if(!tower) {
+    if (!tower) {
         return { status: -1, resResult: resResult(STATUS.TOWER_NOT_FOUND) };
     }
     let { heroes: recHeroes = [], warStatus = [] } = tower;
@@ -44,9 +44,11 @@ export async function checkTowerWar(roleId: string, battleId: number, heroes: Ar
         return { status: -1, resResult: resResult(STATUS.TOWER_DUPLICATE_CHALLENGE) };
     }
 
-    return { status: 0, data: {
+    return {
+        status: 0, data: {
             heroes: recHeroes, warStatus: curWarStatus
-    }};
+        }
+    };
 }
 
 export async function towerBattleEnd(sid: string, funcs: number[], roleId: string, serverId: number, battleCode: string, battleId: number, succeed: boolean, heroes: Array<number>) {
@@ -81,20 +83,21 @@ export async function towerBattleEnd(sid: string, funcs: number[], roleId: strin
             if (nextTowerInfo) {
                 const { warArray } = nextTowerInfo;
                 const sts = warArray.map(id => {
-                    return {warId: id, status: false};
+                    return { warId: id, status: false };
                 });
 
-                await TowerRecordModel.createRecord({roleId, lv: towerLv + 1, warStatus: sts});
+                await TowerRecordModel.createRecord({ roleId, lv: towerLv + 1, warStatus: sts });
 
             }
             const { reward } = gameData.tower.get(towerLv);
             if (reward) towerReward = reward;
             if (towerLv + 1 == HANG_UP_CONSTS.ENABLE_LV) {
                 await startHangUp(roleId, roleName);
-                pinus.app.get('channelService').pushMessageByUids('hangUpEnable', resResult(STATUS.SUCCESS, {enable: true}), [{uid: roleId, sid}]);
+                pinus.app.get('channelService').pushMessageByUids('hangUpEnable', resResult(STATUS.SUCCESS, { enable: true }), [{ uid: roleId, sid }]);
             }
             // 任务
             await checkTask(roleId, sid, funcs, TASK_TYPE.BATTLE_TOWER_LV, role.towerLv, false, {});
+            await checkActivityTask(serverId, sid, funcs, roleId, TASK_TYPE.BATTLE_TOWER_LV, 1, { towerLv: role.towerLv });
         }
         return {
             status: 0,
@@ -113,20 +116,20 @@ async function startHangUp(roleId: string, roleName: string) {
 
 export async function checkHangUpSpdUpCnt(roleId: string, cnt: number, curTime: Date) {
     const role = await RoleModel.findByRoleId(roleId);
-    let {hangUpSpdUpCnt, gold, lastSpdUpTime} = role;
+    let { hangUpSpdUpCnt, gold, lastSpdUpTime } = role;
     if (!lastSpdUpTime || (shouldRefresh(lastSpdUpTime, curTime) && hangUpSpdUpCnt <= HANG_UP_CONSTS.MAX_SPD_UP_CNT)) {
         hangUpSpdUpCnt = HANG_UP_CONSTS.MAX_SPD_UP_CNT;
     }
     if (cnt > hangUpSpdUpCnt) {
-        return {status: -1, resResult:resResult(STATUS.TOWER_NOT_ENOUGH_HANG_UP_TIME)}
+        return { status: -1, resResult: resResult(STATUS.TOWER_NOT_ENOUGH_HANG_UP_TIME) }
     }
-    return {status: 0, data: {hangUpSpdUpCnt, gold, lastSpdUpTime}}
+    return { status: 0, data: { hangUpSpdUpCnt, gold, lastSpdUpTime } }
 }
 
 export async function calcuHangUpReward(roleId: string, speedUp = false, speedUpCnt = 1, curTime = new Date()) {
     let { towerLv = 1, hangUpSpdUpCnt = 0, lastSpdUpTime } = await RoleModel.findByRoleId(roleId);
-    if(towerLv < HANG_UP_CONSTS.ENABLE_LV) {
+    if (towerLv < HANG_UP_CONSTS.ENABLE_LV) {
-        return {status: -1, resResult: resResult(STATUS.TOWER_HANG_UP_NOT_START)}
+        return { status: -1, resResult: resResult(STATUS.TOWER_HANG_UP_NOT_START) }
     }
 
     let towerInfo = gameData.tower.get(towerLv - 1); // towerLv 是当前层，奖励计算按照已经通过的层，即上一层
@@ -150,41 +153,41 @@ export async function calcuHangUpReward(roleId: string, speedUp = false, speedUp
             let multi = Math.floor(HANG_UP_CONSTS.SPD_UP_REC_TIME / HANG_UP_CONSTS.UNIT_TIME);
             let spdUpRec = await HangUpSpdUpRecModel.getSpdUpRec(roleId, towerLv - 1);
             let goods = [];
-            if(spdUpRec) {
+            if (spdUpRec) {
                 let { notReceivedGoodsList = [], cnt } = spdUpRec;
-                let notReceivedGoods = notReceivedGoodsList.find(cur => cur.cnt == cnt );
+                let notReceivedGoods = notReceivedGoodsList.find(cur => cur.cnt == cnt);
-                goods = notReceivedGoods?notReceivedGoods.goods:[];
+                goods = notReceivedGoods ? notReceivedGoods.goods : [];
             }
-            for(let {id, count} of baseReward) {
+            for (let { id, count } of baseReward) {
                 let newCount = cal.mul(count, multi);
                 let oldGoods = goods.find(cur => cur.gid == id);
-                if(oldGoods) newCount = cal.add(newCount, oldGoods.count);
+                if (oldGoods) newCount = cal.add(newCount, oldGoods.count);
                 let roundCount = Math.floor(newCount);
-                if(newCount > roundCount) {
+                if (newCount > roundCount) {
-                    needReceiveGoods.push({gid: id, count: cal.sub(newCount, roundCount)});
+                    needReceiveGoods.push({ gid: id, count: cal.sub(newCount, roundCount) });
                 }
-                if(roundCount > 0) {
+                if (roundCount > 0) {
-                    timeReward.push({id, count: roundCount})
+                    timeReward.push({ id, count: roundCount })
                 }
             }
         }
     } else {
         let lastRec = await HangUpRecordModel.getLastRec(roleId);
-        let notReceivedGoods = lastRec?lastRec.notReceivedGoods: [];
+        let notReceivedGoods = lastRec ? lastRec.notReceivedGoods : [];
 
         let multi = Math.floor(deltaTime / HANG_UP_CONSTS.UNIT_TIME); // 结算奖励的倍数，受最大时间限制
 
         // console.log(deltaTime, multi, baseReward);
-        for(let {id, count} of baseReward) {
+        for (let { id, count } of baseReward) {
             let newCount = cal.mul(count, multi);
             let oldGoods = notReceivedGoods.find(cur => cur.gid == id);
-            if(oldGoods) newCount = cal.add(newCount, oldGoods.count);
+            if (oldGoods) newCount = cal.add(newCount, oldGoods.count);
             let roundCount = Math.floor(newCount);
-            if(newCount > roundCount) {
+            if (newCount > roundCount) {
-                needReceiveGoods.push({gid: id, count: cal.sub(newCount, roundCount)});
+                needReceiveGoods.push({ gid: id, count: cal.sub(newCount, roundCount) });
             }
-            if(roundCount > 0) {
+            if (roundCount > 0) {
-                timeReward.push({id, count: roundCount})
+                timeReward.push({ id, count: roundCount })
             }
         }
     }
@@ -207,16 +210,16 @@ async function checkCond(roleId: string, heroes, type: number, param: number, cn
 
     switch (type) {
         case 1:
-            for(let seqId of heroes) {
+            for (let seqId of heroes) {
-                const {star, colorStar} = await HeroModel.findBySeqIdAndRole(seqId, roleId);
+                const { star, colorStar } = await HeroModel.findBySeqIdAndRole(seqId, roleId);
                 if (star + colorStar >= param) {
                     heroCnt++;
                 }
             }
             break;
         case 2:
-            for(let seqId of heroes) {
+            for (let seqId of heroes) {
-                let {hid} = await HeroModel.findBySeqIdAndRole(seqId, roleId);
+                let { hid } = await HeroModel.findBySeqIdAndRole(seqId, roleId);
                 const hInfo = gameData.hero.get(hid);
                 if (hInfo.camp === param) {
                     heroCnt++;
@@ -224,8 +227,8 @@ async function checkCond(roleId: string, heroes, type: number, param: number, cn
             }
             break;
         case 3:
-            for(let seqId of heroes) {
+            for (let seqId of heroes) {
-                let {hid} = await HeroModel.findBySeqIdAndRole(seqId, roleId);
+                let { hid } = await HeroModel.findBySeqIdAndRole(seqId, roleId);
                 const hInfo = gameData.hero.get(hid);
                 if (gameData.job.get(hInfo.jobid).job_class === param) {
                     heroCnt++;
@@ -244,7 +247,7 @@ async function checkCond(roleId: string, heroes, type: number, param: number, cn
 export async function checkTaskConditions(roleId: string, heroes: number[], condition: { type: number, param: number, count: number }[]) {
 
     let res = true;
-    for (let {type, param, count} of condition) {
+    for (let { type, param, count } of condition) {
         const checkRes = await checkCond(roleId, heroes, type, param, count);
         if (!checkRes) {
             res = false;
@@ -264,28 +267,28 @@ export async function checkTaskConditions(roleId: string, heroes: number[], cond
 export async function createCurTasks(towerLv: number, batchCode: string, roleId: string, roleName: string, hideNum: number, showNum: number, rids: Array<number>) {
     let randomList = [];
     let dicTask = gameData.towerTask;
-    for(let [ _id, task] of dicTask) {
+    for (let [_id, task] of dicTask) {
-        let {suitFloor: {min, max} } = task;
+        let { suitFloor: { min, max } } = task;
-        let flag = max?(towerLv >= min && towerLv <= max): (towerLv >= min);
+        let flag = max ? (towerLv >= min && towerLv <= max) : (towerLv >= min);
-        if(flag) {
+        if (flag) {
             randomList.push(task);
         }
     }
     let returnTasks = new Array();
-    const arr = [{refreshStatus: 0, num: hideNum}, {refreshStatus: 1, num: showNum}];
+    const arr = [{ refreshStatus: 0, num: hideNum }, { refreshStatus: 1, num: showNum }];
-    for(let {refreshStatus, num} of arr) {
+    for (let { refreshStatus, num } of arr) {
         let taskIds = [];
-        for(let i = 0; i < num; i++) {
+        for (let i = 0; i < num; i++) {
             let list = randomList.filter(cur => !rids.includes(cur.taskId));
-            let {dic: tmp} = getRandEelmWithWeight(list);
+            let { dic: tmp } = getRandEelmWithWeight(list);
-            if(tmp) {
+            if (tmp) {
                 taskIds.push(tmp.taskId);
                 rids.push(tmp.taskId)
             }
         }
         const curTasks = await TowerTaskRecModel.createTasks(roleId, roleName, batchCode, taskIds, refreshStatus);
 
-        if(refreshStatus == 1) {
+        if (refreshStatus == 1) {
             returnTasks = curTasks;
         }
     }
@@ -295,12 +298,12 @@ export async function createCurTasks(towerLv: number, batchCode: string, roleId:
 
 export function getRemainTime(curTime: Date) {
     let nextTime = <number>getTimeFunM(curTime).getAfterDayWithHour(1);
-    return Math.floor((nextTime - curTime.getTime())/1000);
+    return Math.floor((nextTime - curTime.getTime()) / 1000);
 }
 
 export function treatTask(recs: Array<any>, curTime: Date) {
     return recs.map(cur => {
-        let { heroes, batchCode, taskId, taskCode, status, completeTime} = cur;
+        let { heroes, batchCode, taskId, taskCode, status, completeTime } = cur;
 
         let getStatusResult = getTaskStatus(status, completeTime, curTime);
         return { heroes, batchCode, taskId, taskCode, completeTime, ...getStatusResult }
@@ -308,43 +311,43 @@ export function treatTask(recs: Array<any>, curTime: Date) {
 }
 
 // 刷新任务，正在进行中的部分保留，没有进行中的刷掉
-export function getDoingOrWaitingTasks (taskList: Array<any>, curTime: Date) {
+export function getDoingOrWaitingTasks(taskList: Array<any>, curTime: Date) {
     let doingTaskCode = new Array<string>(), waitingTaskCode = new Array<string>(), doingIds = new Array<number>();
-    for(let task of taskList) {
+    for (let task of taskList) {
-        let {status} = getTaskStatus(task.status, task.completeTime, curTime);
+        let { status } = getTaskStatus(task.status, task.completeTime, curTime);
-        if(status == 1||status == 2) {
+        if (status == 1 || status == 2) {
             doingTaskCode.push(task.taskCode);
             doingIds.push(task.taskId);
-        } else if(status == 0|| status == 3) {
+        } else if (status == 0 || status == 3) {
             waitingTaskCode.push(task.taskCode);
         }
     }
-    return {doingTaskCode, waitingTaskCode, doingIds}
+    return { doingTaskCode, waitingTaskCode, doingIds }
 }
 
 export function getTaskStatus(status: number, completeTime: Date, curTime: Date) {
     let remainTime = 0;
-    if(status == 1) {
+    if (status == 1) {
         // console.log(curTime.getTime(), completeTime.getTime())
-      remainTime = Math.floor((completeTime.getTime() - curTime.getTime())/1000);
+        remainTime = Math.floor((completeTime.getTime() - curTime.getTime()) / 1000);
-      if(remainTime < 0) {
+        if (remainTime < 0) {
             status = 2; remainTime = 0;
         }
     }
 
-    return {status, remainTime}
+    return { status, remainTime }
 }
 
 export async function getTasksReward(roleId: string, curTime: Date) {
     let oldTasks = await TowerTaskRecModel.getCurTasks(roleId);
     let goods: ItemInter[] = [];
-    for(let task of oldTasks) {
+    for (let task of oldTasks) {
-        let {completeTime, reward, termsForAdd, additionalReward} = gameData.towerTask.get(task.taskId);
+        let { completeTime, reward, termsForAdd, additionalReward } = gameData.towerTask.get(task.taskId);
         if (task.sendTime && task.sendTime.getTime() + completeTime * 1000 < curTime.getTime()) {
             goods = goods.concat(reward);
-            if(termsForAdd) {
+            if (termsForAdd) {
                 const result = checkTaskConditions(roleId, task.heroes, termsForAdd);
-                if(result) {
+                if (result) {
                     goods = goods.concat(additionalReward);
                 }
             }
@@ -369,7 +372,7 @@ export function getRandRobot(cnt = 1, withAttr = false) {
         if (!warInfo || !warInfo.length) continue;
 
         let heroes = [];
-        for(let hero of warInfo) {
+        for (let hero of warInfo) {
             if (hero && hero.relation === 2 && hero.actorId) {
                 heroes.push(hero.actorId);
             }
@@ -383,11 +386,11 @@ export function getRandRobot(cnt = 1, withAttr = false) {
  * 拷贝敌军数组并添加当前血量字段
  * @param source 原敌军数组，不包含当前血量字段
  */
-export function transBossHpArr(source: Array<{dataId: number, hp: number, actorId: number}>): Array<{dataId: number, hp: number, curHp: number, actorId: number}> {
+export function transBossHpArr(source: Array<{ dataId: number, hp: number, actorId: number }>): Array<{ dataId: number, hp: number, curHp: number, actorId: number }> {
     let desArr = [];
     source.forEach(elem => {
         let { hp } = elem;
-        desArr.push(Object.assign(elem, {curHp: hp}));
+        desArr.push(Object.assign(elem, { curHp: hp }));
     });
     return cloneDeep(desArr);
 }

game-server/app/services/growthFundService.ts

@@ -97,7 +97,7 @@ export async function getPlayerGrowthFundData(activityId: number, serverId: numb
                 for (let page of playerData.list) {
                     for (let item of page.items) {
                         if (item.taskType == TASK_TYPE.BATTLE_MAIN_ELITE) {
-                            if (mainEliteWarId >= item.condition) {
+                            if (mainEliteWarId >= item.taskParamArray[1]) {
                                 item.isComplete = true;
                             }
                         }

game-server/app/services/limitPackageService.ts

@@ -5,6 +5,7 @@ import { ActivityShopModel, ActivityShopModelType } from '../db/ActivityShop';
 import { RoleModel } from '../db/Role';
 import { ServerlistModel } from '../db/Serverlist';
 import { LimitShopData, ShopItem } from '../domain/activityField/limitShopField';
+import { deltaDays } from '../pubUtils/util';
 
 /**
    * 获取新手玩家限购礼包活动数据  新手限定作为开服七天乐的延伸礼包。只存在于开服前七天，七天时间过去，玩家无法购买
@@ -16,9 +17,6 @@ import { LimitShopData, ShopItem } from '../domain/activityField/limitShopField'
    */
 
 export async function newPlayerLimitPackageActivity(serverId: number, roleId: string) {
-    let { createTime } = await RoleModel.findByRoleId(roleId);
-    let createDate = moment(createTime * 1000).toDate();
-
     let { activityGroupId } = await ServerlistModel.findByServerId(serverId);
     let activityArray: ActivityModelType[] = await ActivityModel.findOpenActivityByType(activityGroupId, ACTIVITY_TYPE.NEW_PLAYER_LIMIT_PACKAGE, new Date)
     if (activityArray.length == 0) {
@@ -72,3 +70,18 @@ export async function limitPackageActivity(serverId: number, roleId: string, typ
     let playerData = await getPlayerLimitPackageData(activityData.activityId, serverId, roleId);
     return playerData
 }
+
+/**
+   * 玩家活动第几天
+   *
+   * @param {number} serverId 区Id
+   * @param {number} activityId 活动Id
+   * @param {string} roleId 角色Id
+   *
+   */
+export async function newPlayerActivityDays(roleId: string) {
+    let { createTime } = await RoleModel.findByRoleId(roleId);
+    let createDate = moment(createTime * 1000).toDate();
+    let todayIndex = deltaDays(moment(createDate).startOf('d').toDate(), new Date) + 1;
+    return todayIndex;
+}

game-server/app/services/rechargeMoneyService.ts

@@ -25,6 +25,7 @@ export async function rechargeMoneyActivity(serverId: number, roleId: string) {
     let playerRecord: ActivityRechargeMoneyModelType[] = await ActivityRechargeMoneyModel.findData(serverId, roleId);
     let playerData = new RechargeMoneyData(activityData);
     playerData.setPlayerRecords(playerRecord);
+    delete playerData.recordArray;
     return playerData;
 
     // let playerDataArray = [];

shared/consts/constModules/activityConst.ts

@@ -30,6 +30,10 @@ export enum ACTIVITY_TYPE {
     DAILY_RMB_GIFTS = 22, // 每日特惠RMB购买，一次性购买7天礼包
     TREASURE_HUNT = 23, // 寻宝骑兵活动
     POP_UP_SHOP = 24, // 弹出商店
+    FOURTEEN_DAY = 25, // 14天乐活动(虚)
+    FOURTEEN_DAILY_DISCOUNT_GIFT = 26, // 14天乐活动,每日特惠礼包
+    FOURTEEN_TASK_GROWTH = 27, // 14天乐成长任务活动
+    FOURTEEN_TASK_DAILY_CHALLENGES = 28, // 14天乐今日挑战活动
 }
 
 /**

shared/domain/activityField/growthFundField.ts

@@ -26,7 +26,7 @@ export class GrowthFundItem {
         this.taskType = data.taskType;
         this.taskParam = data.taskParam;
         this.reward = data.reward;
-        this.condition = data.conditon;
+        this.condition = data.condition;
         this.isComplete = false;
         // this.isReceive = false;
         this.taskParamArray = splitString(data.taskParam, '&')
@@ -80,10 +80,16 @@ export class GrowthFundData extends ActivityBase {
                         break;
                     }
                     case ACTIVITY_TYPE.GROWTH_FUND_TOWER:
-                    case ACTIVITY_TYPE.GROWTH_FUND_TOWER_VIP:
+                    case ACTIVITY_TYPE.GROWTH_FUND_TOWER_VIP: {
+                        if (!this.isReceive(page.pageIndex, item.cellIndex) && item.condition <= condition) {
+                            item.isComplete = true;
+                            items.push(Object.assign(item, { pageIndex: page.pageIndex, activityId: this.activityId }))
+                        }
+                        break;
+                    }
                     case ACTIVITY_TYPE.GROWTH_FUND_MAIN_ELITE:
                     case ACTIVITY_TYPE.GROWTH_FUND_MAIN_ELITE_VIP: {
-                        if (!this.isReceive(page.pageIndex, item.cellIndex) && item.condition <= condition) {
+                        if (!this.isReceive(page.pageIndex, item.cellIndex) && item.taskParamArray[1] <= condition) {
                             item.isComplete = true;
                             items.push(Object.assign(item, { pageIndex: page.pageIndex, activityId: this.activityId }))
                         }

shared/pubUtils/taskUtil.ts

@@ -517,7 +517,7 @@ export async function accomplishTask(serverId: number, roleId: string, taskType:
         let taskArray = growthActivity.findTaskByType(taskType, growthActivity.today());
         for (let task of taskArray) {
             let taskRecord = await ActivityDailyChallengesModel.findDataByCellIndex(serverId, growthActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType)
-            let recordData = taskRecord && taskRecord.data ? taskRecord.data : {}
+            let recordData = taskRecord && taskRecord.data ? JSON.parse(taskRecord.data) : null
             let { addCount, record } = isComplete(roleId, task.taskType, task.taskParam, count, parma, recordData);
             if (addCount) {
                 if (taskType == TASK_TYPE.ROLE_LV || taskType == TASK_TYPE.ROLE_TITLE) {
@@ -554,7 +554,7 @@ export async function accomplishTask(serverId: number, roleId: string, taskType:
             let taskArray = thirtyDaysActivity.findUncompleteTaskByType(taskType);
             for (let task of taskArray) {
                 let taskRecord = await ActivityDailyChallengesModel.findDataByCellIndex(serverId, thirtyDaysActivity.activityId, roleId, task.dayIndex, task.cellIndex, task.taskType)
-                let recordData = taskRecord && taskRecord.data ? taskRecord.data : {}
+                let recordData = taskRecord && taskRecord.data ? JSON.parse(taskRecord.data) : null
                 let { addCount, record } = isComplete(roleId, task.taskType, task.taskParam, count, parma, recordData);
                 if (addCount) {
                     await ActivityThirtyDaysModel.addTaskCount(serverId, thirtyDaysActivity.activityId, roleId, task.pageIndex, task.cellIndex, task.taskType, addCount);
@@ -593,7 +593,7 @@ export async function accomplishTask(serverId: number, roleId: string, taskType:
                 let buyRecords = await ActivityBuyRecordsModel.findRecordsByActivityId(activity.activityId, roleId);
                 growthFundActivity.initBuyRecords(buyRecords);
             }
-            let taskArray = growthFundActivity.unLockItem(parma.warId);
+            let taskArray = growthFundActivity.unLockItem(parma.towerLv);
             //推送
             pushMessage = pushMessage.concat(taskArray);
         }
@@ -609,7 +609,7 @@ export async function accomplishTask(serverId: number, roleId: string, taskType:
                 let buyRecords = await ActivityBuyRecordsModel.findRecordsByActivityId(activity.activityId, roleId);
                 growthFundActivity.initBuyRecords(buyRecords);
             }
-            let taskArray = growthFundActivity.unLockItem(parma.warId);
+            let taskArray = growthFundActivity.unLockItem(parma.mainEliteWarId);
             //推送
             pushMessage = pushMessage.concat(taskArray);
         }
@@ -720,10 +720,10 @@ export function isComplete(roleId: string, taskType: TASK_TYPE, taskParam: strin
                     break;
                 }
                 if (recordData) {
+                    record = recordData;
                     if (recordData.indexOf(hid) != -1) {
                         break;
                     }
-                    record = recordData;
                 } else {
                     record = [];
                 }
@@ -742,15 +742,20 @@ export function isComplete(roleId: string, taskType: TASK_TYPE, taskParam: strin
                 let hid = paramObj.hid;
                 if (recordData) {
                     record = recordData;
-                    if (record['hid']) {
+                    let oldCount = record[hid];
-                        if (record['hid'] < param[1] && (record['hid'] + count >= param[1])) {
+                    if (oldCount) {
+                        if (oldCount < param[1] && (oldCount + count >= param[1])) {
                             addCount = count;
-                            record['hid'] += count;
+                            record[hid] = oldCount + count;
                             break;
                         }
+                    } else {
+                        record[hid] = count;
                     }
+                } else {
+                    record = {};
+                    record[hid] = count;
                 }
-                record['hid'] = count;
                 break;
             }
         case TASK_TYPE.BATTLE_EXPEDITION:

shared/resource/jsons/dic_zyz_taskType.json

@@ -1083,10 +1083,10 @@
         "id": 73,
         "name": "精英任务",
         "info": "精英通关第x关",
-        "param": "warid&",
+        "param": "count&warid&",
         "string": "关卡id",
         "content": 0,
-        "condition": "warid",
+        "condition": "count",
         "__EMPTY": 0,
         "__EMPTY_1": 0,
         "__EMPTY_2": 0,