🐞 fix(活动): 活动限时道具的时限来源修改

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

@@ -88,7 +88,7 @@ export class ForgeHandler {
         playerData.setPlayerData(playerRecord);
         playerData.incPlayCnt();
 
-        let rewards = stringToRewardParam(playerData.reward, playerData.nextRefreshTime);
+        let rewards = stringToRewardParam(playerData.reward);
         let { goods } = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_MINI_GAME_REWARD);
 
         let r = new Rank(REDIS_KEY.ACTIVITY_MINI_GAME, { activityId, roundIndex: playerData.roundIndex });
@@ -158,7 +158,7 @@ export class ForgeHandler {
         if(!result) return resResult(STATUS.ACTIVITY_MINI_GAME_BOX_HAS_RECEIVED);
         playerData.setPlayerData(result);
 
-        let rewards = stringToRewardParam(box.reward, playerData.nextRefreshTime);
+        let rewards = stringToRewardParam(box.reward);
         let { goods } = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_MINI_GAME_REWARD);
 
         return resResult(STATUS.SUCCESS, {

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

@@ -76,7 +76,7 @@ export class RefreshShopHandler {
         let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.BUY_REFRESH_SHOP);
         if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
 
-        let rewardArray = stringToRewardParam(item.reward, playerData.nextRefreshTime).map(cur => ({...cur, count: cur.count * count }));
+        let rewardArray = stringToRewardParam(item.reward).map(cur => ({...cur, count: cur.count * count }));
         let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.BUY_REFRESH_SHOP);
 
         await ActivityRefreshShopModel.addRecord(activityId, roleId, roundIndex, pageIndex, id, count);

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

@@ -70,7 +70,7 @@ export class RefreshTaskHandler {
 
         await ActivityRefreshTaskModel.addReceiveRecord(serverId, activityId, roleId, roundIndex, pageIndex, id, dailyItemData.getRefTime(), 1);
 
-        let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward, playerData.nextRefreshTime);
+        let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
         let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.REFRESH_TASK_REWARD)
 
         //获得点数
@@ -110,7 +110,7 @@ export class RefreshTaskHandler {
 
         await ActivityRefreshTaskPointModel.addReceiveRecord(serverId, activityId, roleId, playerData.consumePoint);
 
-        let rewardParamArr: Array<RewardParam> = stringToRewardParam(playerData.reward, playerData.nextRefreshTime);
+        let rewardParamArr: Array<RewardParam> = stringToRewardParam(playerData.reward);
         let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.REFRESH_TASK_EXCHANGE)
 
         playerData.exchangePoint += playerData.consumePoint;

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

@@ -101,7 +101,7 @@ export class SignInHandler {
 
         await ActivitySignInModel.addSignInRecord(activityId, roleId, roundIndex, dayIndex);
 
-        let rewardParamArr: Array<RewardParam> = stringToRewardParam(signinItemData.reward, playerData.nextRefreshTime);
+        let rewardParamArr: Array<RewardParam> = stringToRewardParam(signinItemData.reward);
         let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.SIGNIN)
 
         return resResult(STATUS.SUCCESS, Object.assign(result, {

game-server/app/services/activity/giftPackageService.ts

@@ -275,19 +275,15 @@ async function randomSelectedData(pool: DicGiftPackagePlan[], roleId: string, gi
 }
 
 //数据格式转换'类型&id&数量|类型&id&数量|' ->> Array<RewardParam> 活动奖励
-export function stringToRewardParam(rewardStr: string, expireTime?: number): Array<RewardParam> {
+export function stringToRewardParam(rewardStr: string): Array<RewardParam> {
-    let result = new Array<{ type: number, id: number, count: number, expireTime?: number }>();
+    let result = new Array<{ type: number, id: number, count: number }>();
     if (!rewardStr) return result;
     let decodeArr = decodeArrayListStr(rewardStr);
     for (let [type, id, count] of decodeArr) {
         if (isNaN(parseInt(type)) || isNaN(parseInt(id)) || isNaN(parseInt(count))) {
             continue;
         }
-        if(expireTime && isNumber(expireTime)) {
+        result.push({ type: parseInt(type), id: parseInt(id), count: parseInt(count) });
-            result.push({ type: parseInt(type), id: parseInt(id), count: parseInt(count), expireTime: Math.floor(expireTime/1000) });
-        } else {
-            result.push({ type: parseInt(type), id: parseInt(id), count: parseInt(count) });
-        }
     }
     return result
 }

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

@@ -1,4 +1,4 @@
-import { ITID, CONSUME_TYPE, ITEM_TABLE, CURRENCY_TYPE, MAIL_TYPE, HANDLE_REWARD_TYPE, HERO_SYSTEM_TYPE, CURRENCY_BY_TYPE, ITEM_CHANGE_REASON, TA_USERSET_TYPE, TA_EVENT, POP_UP_SHOP_CONDITION_TYPE, ROLE_SELECT, FIGURE_UNLOCK_CONDITION, PUSH_ROUTE } from '../../consts';
+import { ITID, CONSUME_TYPE, ITEM_TABLE, CURRENCY_TYPE, MAIL_TYPE, HANDLE_REWARD_TYPE, HERO_SYSTEM_TYPE, CURRENCY_BY_TYPE, ITEM_CHANGE_REASON, TA_USERSET_TYPE, TA_EVENT, POP_UP_SHOP_CONDITION_TYPE, ROLE_SELECT, FIGURE_UNLOCK_CONDITION, PUSH_ROUTE, ACTIVITY_TYPE } from '../../consts';
 import { getDecimalCnt, getRandEelm, getRandEelmWithWeight, getRandValueByMinMax, } from '../../pubUtils/util';
 import { RoleModel, RoleType } from '../../db/Role';
 import { setAp } from '../actionPointService';
@@ -24,6 +24,10 @@ import { sendMessageToUserWithSuc } from '../pushService';
 import { filterGoods } from '../dataService';
 import { ArtifactModel, ArtifactModelType, ArtifactModelUpdate } from '../../db/Artifact';
 import { ActivityItemModel } from '../../db/ActivityItem';
+import { getActivitiesByType } from '../activity/activityService';
+import { ActivityModelType } from '../../db/Activity';
+import { ForgeData } from '../../domain/activityField/forgeField';
+import { getRoleCreateTime, getServerCreateTime } from '../redisService';
 
 export async function handleCost(roleId: string, sid: string, goods: Array<ItemInter>, reason: ITEM_CHANGE_REASON) {
 
@@ -146,7 +150,7 @@ export async function addItems(roleId: string, roleName: string, sid: string, go
     goods = filterGoods(goods, obj => obj.id, roleId, reason);
     let { items, jewels, gold, coin, ap, skins, figures, artifacts, activityItems } = sortItems(goods, HANDLE_REWARD_TYPE.RECEIVE);
     let showItems: { id: number, seqId?: number, count: number, isBag?: boolean, expireTime?: number }[] = [];
-    let role = await RoleModel.findByRoleId(roleId);
+    let role = await RoleModel.findByRoleId(roleId, '-warCount -topLineup');
     // 1. 装备处理
     if(jewels.length > 0) {
         let { jewelCount = 0 } = role;
@@ -293,9 +297,9 @@ export async function addItems(roleId: string, roleName: string, sid: string, go
 
     // 7. 活动道具处理
     if(activityItems.length > 0) {
-        let { items: itemInfos } = await addActivityItems(roleId, roleName, activityItems, reason);
+        let { items: itemInfos } = await addActivityItems(role, activityItems, reason);
-        for (let item of activityItems) {
+        for (let item of itemInfos) {
-            showItems.push({ id: item.id, count: item.count, expireTime: item.expireTime });
+            showItems.push({ id: item.id, count: item.inc, expireTime: item.expireTime });
         }
         //背包除去装备推送 
         if (!!itemInfos.length) {
@@ -460,20 +464,36 @@ export async function addBag(roleId: string, roleName: string, data: { id: numbe
     return { id: item.id, count: item.count, inc: count, reason };
 }
 
-export async function addActivityItems(roleId: string, roleName: string, datas: { id: number, count: number, expireTime?: number }[], reason: number) {
+export async function addActivityItems(role: RoleType, datas: { id: number, count: number }[], reason: number) {
+    let serverTime = await getServerCreateTime(role.serverId);
+    let createTime = await getRoleCreateTime(role.roleId, role);
     let items: { id: number, count: number, inc: number, expireTime: number }[] = [];
     for(let data of datas) {
-        let item = await addActivityItem(roleId, roleName, data, reason);
+        let item = await addActivityItem(role.serverId, role.roleId, role.roleName, data, reason, createTime, serverTime);
-        items.push(item)
+        if(item) items.push(item)
     }
     return { items }
 }
 
-export async function addActivityItem(roleId: string, roleName: string, data: { id: number, count: number, expireTime?: number }, reason: number) {
+export async function addActivityItem(serverId: number, roleId: string, roleName: string, data: { id: number, count: number }, reason: number, createTime: number, serverTime: number) {
-    let { id, count, expireTime } = data;
+    let { id, count } = data;
-    let { name: itemName, itid } = gameData.goods.get(id);
+    let { name: itemName, activityType } = gameData.goods.get(id);
-    let item = await ActivityItemModel.increaseActivityItem(roleId, id, count, { roleId, roleName, itemName, id, expireTime });
+    let activities = await getActivitiesByType(serverId, activityType);
-    return { id: item.id, count: item.count, inc: count, expireTime: item.expireTime, reason };
+    if(activities.length > 0) {
+        let activityData = getActivityData(activities[0], createTime, serverTime);
+        if(!activityData || !activityData.canShow()) return null;
+        let item = await ActivityItemModel.increaseActivityItem(roleId, id, count, { roleId, roleName, itemName, id, expireTime: activityData.nextRefreshTime });
+        return { id: item.id, count: item.count, inc: count, expireTime: item.expireTime, reason };
+    }
+}
+
+function getActivityData(activity: ActivityModelType, createTime: number, serverTime: number) {
+    switch(activity.type) {
+        case ACTIVITY_TYPE.FORGE:
+            return new ForgeData(activity, createTime, serverTime)      
+        default:
+            return null
+    }
 }
 
 export async function addJewels(roleId: string, roleName: string, jewels: { id: number, }[], reason: number) {

shared/pubUtils/dictionary/DicGoods.ts

@@ -36,6 +36,8 @@ export interface DicGoods {
     readonly gift: number;
     // 是否可以用于pvp随机
     readonly randomShow: number;
+    // 关联活动
+    readonly activityType: number;
 }
 
 type KeysEnum<T> = { [P in keyof Required<T>]: true };
@@ -54,6 +56,7 @@ const DicGoodsKeys: KeysEnum<DicGoods> = {
     image_id: true,
     gift: true,
     randomShow: true,
+    activityType: true,
 }
 export const dicGoods = new Map<number, DicGoods>();
 export const figureCondition = new Map<number, { params: number[], id: number, gid: number }[]>(); // type => {params, id, gid}

shared/resource/jsons/dic_email_content.json

@@ -318,7 +318,7 @@
         "id": 45,
         "title": "&",
         "sendName": "学宫驿使",
-        "content": "月基金",
+        "content": "亲爱的百家传人，您购买的本期月旦基金有签到奖励尚未领取，现已发送至邮箱，请查收",
         "time": 720
     }
 ]