xinyuxi/ZYZ
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

将两种任务初步合起来

Browse Source
This commit is contained in:
陆莹
2022-03-17 20:24:20 +08:00
parent fdecaf2d74
commit 37d2e6cfa7
51 changed files with 653 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
game-server/app/servers/activity/handler/activityHandler.ts
View File

@@ -1,7 +1,7 @@
import { Application, BackendSession, HandlerService, pinus, } from 'pinus';
import { aesEncrypt, aesEncryptcfb, resResult } from '../../../pubUtils/util';
import { ENCRYPT_IV, ENCRYPT_KEY, STATUS, TASK_TYPE } from '../../../consts';
import { checkActivityTask } from '../../../services/taskService';
import { checkActivityTask } from '../../../services/task/taskService';
import { ActivityGroupModel } from '../../../db/ActivityGroup';
import { ServerlistModel } from '../../../db/Serverlist';
import { getActivity, getActivityById } from '../../../services/activity/activityService';

2
game-server/app/servers/activity/handler/gachaHandler.ts
View File

@@ -11,7 +11,7 @@ import { handleCost, createHeroes, addItems } from "../../../services/role/rewar
import { getZeroPointD, getTimeFun } from "../../../pubUtils/timeUtil";
import { UserGachaRecModel } from "../../../db/UserGachaRec";
import { ActivityModel } from "../../../db/Activity";
import { checkActivityTask, checkTask } from "../../../services/taskService";
import { checkActivityTask, checkTask } from "../../../services/task/taskService";
import { RECRUIT } from "../../../pubUtils/dicParam";
import { getActivityById } from "../../../services/activity/activityService";

10
game-server/app/servers/activity/remote/activityRemote.ts
View File

@@ -2,7 +2,7 @@ import { Application, ChannelService, HandlerService, } from 'pinus';
import { ActivityModel, ActivityModelType } from '../../../db/Activity';
import { ServerlistModel } from '../../../db/Serverlist';
import { reloadResources } from '../../../pubUtils/data';
import { _getActivitiesByType, _getActivityById, _getActivities } from '../../../services/activity/activityService';
import { _getActivitiesByType, _getActivityById, _getActivities, _getActivitiesByServerId } from '../../../services/activity/activityService';
import { getServerMainten, setServerMainten, stopServerMainten } from '../../../services/gmService';
import { taflush } from '../../../services/sdkService';
import { ActivityInRemote } from '../../../domain/activityField/activityField';
@@ -173,6 +173,14 @@ export class ActivityRemote {
}
}
public getActivitiesByServerId(serverId: number) {
try {
return _getActivitiesByServerId(serverId);
} catch(e) {
errlogger.error(`remote ${__filename} \n ${e.stack}`);
}
}
public getActivities() {
try {
return _getActivities();

2
game-server/app/servers/battle/handler/comBattleHandler.ts
View File

@@ -24,7 +24,7 @@ import { pushComBtlTeamMsg, pushFriendTeamInviteMsg, pushNormalItemMsg, pushTeam
import { EXTERIOR } from '../../../pubUtils/dicParam';
import { getZeroPointD, getTimeFunD, getSeconds, nowSeconds } from '../../../pubUtils/timeUtil';
import { FriendParams } from '../../../domain/roleField/friend';
import { checkActivityTask, checkTask, checkTaskInComBattleStart, checkTaskWithArgs, checkTaskWithGoods } from '../../../services/taskService';
import { checkActivityTask, checkTask, checkTaskInComBattleStart, checkTaskWithArgs, checkTaskWithGoods } from '../../../services/task/taskService';
import { gameData, getWarByBlueprtId } from '../../../pubUtils/data';
import { HeroModel } from '../../../db/Hero';

2
game-server/app/servers/battle/handler/eventBattleHandler.ts
View File

@@ -6,7 +6,7 @@ import { checkEventStatus, getEventSuccessStatus, getEvent, checkQuiz, startEven
import { addItems } from '../../../services/role/rewardService';
import { STATUS } from '../../../consts/statusCode';
import { resResult } from '../../../pubUtils/util';
import { checkActivityTask, checkTask } from '../../../services/taskService';
import { checkActivityTask, checkTask } from '../../../services/task/taskService';
import { gameData } from '../../../pubUtils/data';
export default function (app: Application) {

2
game-server/app/servers/battle/handler/expeditionBattleHandler.ts
View File

@@ -13,7 +13,7 @@ import { getAp, setAp } from '../../../services/actionPointService';
import { STATUS } from '../../../consts/statusCode';
import { resResult } from '../../../pubUtils/util';
import { calculateWarStar, checkBattleHeroes, roleLevelup } from '../../../services/normalBattleService';
import { checkActivityTask, checkTask, checkTaskInBattleEnd } from '../../../services/taskService';
import { checkActivityTask, checkTask, checkTaskInBattleEnd } from '../../../services/task/taskService';
import { gameData } from '../../../pubUtils/data';
import * as dicParam from '../../../pubUtils/dicParam';
import { getSeconds, nowSeconds } from '../../../pubUtils/timeUtil';

2
game-server/app/servers/battle/handler/normalBattleHandler.ts
View File

@@ -19,7 +19,7 @@ import { gameData } from '../../../pubUtils/data';
import { pushMysteryFirstMsg, pushTowerMsg, pushVestigeFirstMsg } from '../../../services/chatService';
import { getSeconds, nowSeconds } from '../../../pubUtils/timeUtil';
import { Rank } from '../../../services/rankService';
import { checkTaskWithWar, checkTaskInBattleEnd, checkActivityTask, checkTaskInBattleSweep } from '../../../services/taskService';
import { checkTaskWithWar, checkTaskInBattleEnd, checkActivityTask, checkTaskInBattleSweep } from '../../../services/task/taskService';
import { ActivitySelfServiceModel } from '../../../db/ActivitySelfService';
import { getSelfServiceShopActivityData } from '../../../services/activity/selfServiceShopActivityService';
import { challengeDailyGK } from '../../../services/activity/dailyGKService';

2
game-server/app/servers/battle/handler/pvpHandler.ts
View File

@@ -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/taskService';
import { checkActivityTask, 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';

2
game-server/app/servers/chat/handler/chatHandler.ts
View File

@@ -4,7 +4,7 @@ import { resResult } from '../../../pubUtils/util';
import { DEFAULT_MSG_PER_PAGE, STATUS, TASK_TYPE } from '../../../consts';
import { createAccuseData, createGroupMsg, createPrivateMsg, getPrivateMessages, pushGroupMsgToRoom, pushMsgToRole, updatePrivateMsgReadInfo, recentPrivateChatInfos, recentWorldMsgs, recentSysMsgs, recentGuildMsgs, updatePrivateMsgIsTop, delPrivateMsg } from '../../../services/chatService';
import { getSimpleRoleInfo } from '../../../services/roleService';
import { checkActivityTask, checkTaskWithArgs } from '../../../services/taskService';
import { checkActivityTask, checkTaskWithArgs } from '../../../services/task/taskService';
import { RoleModel } from '../../../db/Role';

2
game-server/app/servers/connector/handler/entryHandler.ts
View File

@@ -16,7 +16,7 @@ import { rmRoleFromQueue, roleLeave, getRoleOnlineInfo, roleLogin } from '../../
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/taskService';
import { checkTaskWithRole, } from '../../../services/task/taskService';
import { pushData, everydayRefresh, kickUser } from '../../../services/connectorService';
// import { setComBtlOnUserLeave } from '../../../services/comBattleService';
import Counter from '../../../db/Counter';

2
game-server/app/servers/guild/handler/cityActivityHandler.ts
View File

@@ -14,7 +14,7 @@ import { GUILDACTIVITY, SERVER_DEBUG_MODE } from "../../../pubUtils/dicParam";
import { handleCost } from "../../../services/role/rewardService";
import { addActive } from "../../../services/guildService";
import { Rank } from "../../../services/rankService";
import { checkActivityTask, checkTask } from "../../../services/taskService";
import { checkActivityTask, checkTask } from "../../../services/task/taskService";
import { guildInter } from "../../../pubUtils/interface";
import { dispatch } from "../../../pubUtils/dispatcher";
import { ServerRecordModel } from "../../../db/ServerRecords";

2
game-server/app/servers/guild/handler/donateHandler.ts
View File

@@ -12,7 +12,7 @@ import { addFund, getDonation } from '../../../services/donateService';
import { getUserGuildWithRefActive, refreshUserGuild } from '../../../services/guildService';
import { ARMY } from '../../../pubUtils/dicParam';
import { addActive } from '../../../services/guildService'
import { checkActivityTask, checkTask } from '../../../services/taskService';
import { checkActivityTask, checkTask } from '../../../services/task/taskService';
import { guildInter } from '../../../pubUtils/interface';
import { lockData } from '../../../services/redLockService';
import { getVipDonateConsume } from '../../../services/activity/monthlyTicketService';

2
game-server/app/servers/guild/handler/gateActivityHandler.ts
View File

@@ -14,7 +14,7 @@ import { UserGuildModel } from "../../../db/UserGuild";
import { GuildActivityCityModel } from "../../../db/GuildActivityCity";
import { Rank } from "../../../services/rankService";
import { getTimeFun, getZeroPointD } from "../../../pubUtils/timeUtil";
import { checkActivityTask, checkTask } from "../../../services/taskService";
import { checkActivityTask, checkTask } from "../../../services/task/taskService";
import { guildInter } from "../../../pubUtils/interface";
import { ServerRecordModel } from "../../../db/ServerRecords";

2
game-server/app/servers/guild/handler/guildBossHandler.ts
View File

@@ -14,7 +14,7 @@ import { GuildModel } from '../../../db/Guild';
import { gameData, getAuctionRewardByPoolId, getBossByLv } from '../../../pubUtils/data';
import { lockData } from '../../../services/redLockService';
import { pushGuildBossSucMsg, getGuildChannelSid } from '../../../services/chatService';
import { checkTask } from '../../../services/taskService';
import { checkTask } from '../../../services/task/taskService';
import { guildInter } from '../../../pubUtils/interface';
import { addItems, handleCost } from '../../../services/role/rewardService';
import * as dicParam from '../../../pubUtils/dicParam';

2
game-server/app/servers/guild/handler/guildHandler.ts
View File

@@ -23,7 +23,7 @@ import { removeBossRank } from '../../../services/guildBossService';
import { removeTrainRank } from '../../../services/guildTrainService';
import { pushGuildNoticeUpdateMsg, pushGuildUpStructureMsg, addRoleToGuildChannel, getGuildChannelSid, createGroupMsg, pushGroupMsgToRoom } from '../../../services/chatService';
import { Rank } from '../../../services/rankService';
import { checkActivityTask, checkTask } from '../../../services/taskService';
import { checkActivityTask, checkTask } from '../../../services/task/taskService';
import { guildInter } from '../../../pubUtils/interface';
import * as dicParam from '../../../pubUtils/dicParam';
import { reportTAEvent } from '../../../services/sdkService';

2
game-server/app/servers/guild/handler/guildRefineHandler.ts
View File

@@ -13,7 +13,7 @@ import { ARMY } from '../../../pubUtils/dicParam';
import { CURRENCY_BY_TYPE, CURRENCY_TYPE } from '../../../consts/constModules/itemConst';
import { checkEquipProduceStructureLv, openGuildRefine, refreshRefinCnt } from '../../../services/guildRefineService';
import { DATA_NAME } from '../../../consts/dataName';
import { checkTask } from '../../../services/taskService';
import { checkTask } from '../../../services/task/taskService';
import { guildInter } from '../../../pubUtils/interface';
import { DicArmyDevelopConsume } from '../../../pubUtils/dictionary/DicArmyDevelopConsume';

2
game-server/app/servers/guild/handler/guildTrainHandler.ts
View File

@@ -18,7 +18,7 @@ import { addActive } from '../../../services/guildService';
import { GuildTrainReportModel } from '../../../db/GuildTrainReport';
import { DATA_NAME } from '../../../consts/dataName';
import { pushGuildTrainSucMsg } from '../../../services/chatService';
import { checkActivityTask, checkTask } from '../../../services/taskService';
import { checkActivityTask, checkTask } from '../../../services/task/taskService';
import { sendPopUpActivityData } from '../../../services/guildActivity/guildActivityService';
import { guildInter, RewardInter } from '../../../pubUtils/interface';
import { getGuildTrainGkInfo } from '../../../pubUtils/data';

2
game-server/app/servers/guild/handler/raceActivityHandler.ts
View File

@@ -7,7 +7,7 @@ import { GuildActivityRecordModel } from "../../../db/GuildActivityRec";
import { UserGuildActivityRecModel } from "../../../db/UserGuildActivityRec";
import { addActive } from "../../../services/guildService";
import { Rank } from "../../../services/rankService";
import { checkActivityTask, checkTask } from "../../../services/taskService";
import { checkActivityTask, checkTask } from "../../../services/task/taskService";
import { guildInter } from "../../../pubUtils/interface";
import { getGuildChannelSid } from "../../../services/chatService";
import { ServerRecordModel } from "../../../db/ServerRecords";

2
game-server/app/servers/order/handler/orderHandler.ts
View File

@@ -10,7 +10,7 @@ import { applyOrder37 } from '../../../services/pay/37Pay';
import { settleOrder, settleOrderAli, settleOrderWx } from '../../../services/orderService';
import { addRechargeMoney } from '../../../services/activity/rechargeMoneyService';
import { addVipRechargeMoney } from '../../../services/activity/vipRechargeMoneyService';
import { checkActivityTask } from '../../../services/taskService';
import { checkActivityTask } from '../../../services/task/taskService';
import { getActivityById } from '../../../services/activity/activityService';
import { reportTAEvent } from '../../../services/sdkService';

2
game-server/app/servers/role/handler/friendHandler.ts
View File

@@ -21,7 +21,7 @@ import { FRIEND } from "../../../pubUtils/dicParam";
import { PlayerDetail, PlayerDetailHero } from "../../../domain/battleField/guild";
import { createPrivateMsg, pushMsgToRole, pushPresent } from "../../../services/chatService";
import { Rank } from "../../../services/rankService";
import { checkTaskWithRoles, checkTask, checkActivityTask } from "../../../services/taskService";
import { checkTaskWithRoles, checkTask, checkActivityTask } from "../../../services/task/taskService";
import { ComBattleTeamModel } from "../../../db/ComBattleTeam";
import { JewelModel } from "../../../db/Jewel";

2
game-server/app/servers/role/handler/heroHandler.ts
View File

@@ -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/taskService';
import { checkTaskWithHero, checkTask, checkActivityTask } from '../../../services/task/taskService';
import { isNumber, pick } from 'underscore';
import { updateEplaces } from '../../../services/equipService';
import { addConsumeToHero } from '../../../services/roleService';

2
game-server/app/servers/role/handler/roleHandler.ts
View File

@@ -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/taskService';
import { checkTaskWithHero, checkTask, checkTaskWithArgs, checkActivityTask } from '../../../services/task/taskService';
import { getGoldObject, getCoinObject } from '../../../pubUtils/itemUtils';
import { RScriptRecordModel } from '../../../db/RScriptRecord';
import { SkinModel, SkinUpdate } from '../../../db/Skin';

18
game-server/app/servers/role/handler/taskHandler.ts
View File

@@ -1,13 +1,13 @@
import { Application, BackendSession, pinus, HandlerService, } from "pinus";
import { resResult, parseGoodStr, getRandSingleEelm } from "../../../pubUtils/util";
import { STATUS, TASK_FUN_TYPE, SHOP_REFRESH_TYPE, KING_EXP_RATIO_TYPE, DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON, ACTIVITY_TYPE } from "../../../consts";
import { STATUS, TASK_FUN_TYPE, SHOP_REFRESH_TYPE, KING_EXP_RATIO_TYPE, DEBUG_MAGIC_WORD, ITEM_CHANGE_REASON, ACTIVITY_TYPE, TASK_TYPE } from "../../../consts";
import { gameData } from "../../../pubUtils/data";
import { UserTaskRecModel } from "../../../db/UserTaskRec";
import { addItems } from "../../../services/role/rewardService";
import { UserTaskModel } from "../../../db/UserTask";
import { nowSeconds, getZeroPointD } from "../../../pubUtils/timeUtil";
import { DicDailyTask, DicAchievement, DicMainTask } from "../../../pubUtils/dictionary/DicTask";
import { getMainTask, refDailyTaskBox, removeHistoryTask, getCurTask, checkTask, getPvpTask } from "../../../services/taskService";
import { getMainTask, refDailyTaskBox, removeHistoryTask, getCurTask, checkTask, getPvpTask } from "../../../services/task/taskService";
import { TASK } from "../../../pubUtils/dicParam";
import { ActivityTaskPointModel, ActivityTaskPointModelType } from "../../../db/ActivityTaskPoint";
import { ItemInter, RewardInter } from "../../../pubUtils/interface";
@@ -15,6 +15,8 @@ import { RoleModel } from "../../../db/Role";
import { roleLevelup } from "../../../services/normalBattleService";
import _ = require("underscore");
import { addActvityTaskPoint } from "../../../services/activity/activityService";
import { CheckTask } from "../../../services/task/taskObj";
import { ServerlistModel } from "../../../db/Serverlist";
export default function (app: Application) {
new HandlerService(app, {});
@@ -323,4 +325,16 @@ export class ShopHandler {
console.log('******', _.isEqual([1,2], [1,2,2]))
return resResult(STATUS.SUCCESS, { tasks: [...gameData.taskType]});
}
async test(msg: { magicWord: string }, session: BackendSession) {
let roleId = session.get('roleId');
let serverId = session.get('serverId');
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)
}
}

2
game-server/app/services/actionPointService.ts
View File

@@ -4,7 +4,7 @@
import { ActionPointModel, ActionPointType } from '../db/ActionPoint';
import { TASK_TYPE, STATUS, TA_EVENT, ITEM_CHANGE_REASON } from '../consts';
import { checkActivityTask, checkTask } from './taskService';
import { checkActivityTask, checkTask } from './task/taskService';
import { getDicApByLv } from '../pubUtils/data';
import { pinus } from 'pinus';
import { resResult, shouldRefresh } from '../pubUtils/util';

36
game-server/app/services/activity/activityService.ts
View File

@@ -235,13 +235,15 @@ export async function getActivityById(activityId: number) {
export async function getActivitiesByType(serverId: number, type: number) {
let serverType = pinus.app.getServerType();
let activities: ActivityInRemote[] = [];
if(serverType == 'activity') {
return _getActivitiesByType(serverId, type);
activities = _getActivitiesByType(serverId, type);
} else {
let servers = pinus.app.getServersByType('activity');
let server = getRandSingleEelm(servers);
return <ActivityModelType[]>await pinus.app.rpc.activity.activityRemote.getActivitiesByType.toServer(server.id, serverId, type);
activities = await pinus.app.rpc.activity.activityRemote.getActivitiesByType.toServer(server.id, serverId, type);
}
return activities.map(transActivityInRemoteToModelType);
}
export async function getActivities() {
@@ -255,6 +257,19 @@ export async function getActivities() {
}
}
export async function getActivityByServerId(serverId: number) {
let activities: ActivityInRemote[] = [];
let serverType = pinus.app.getServerType();
if(serverType == 'activity') {
activities = _getActivitiesByServerId(serverId);
} else {
let servers = pinus.app.getServersByType('activity');
let server = getRandSingleEelm(servers);
activities = await pinus.app.rpc.activity.activityRemote.getActivitiesByServerId.toServer(server.id, serverId);
}
return activities.map(transActivityInRemoteToModelType);
}
export function _getActivityById(activityId: number) {
return <ActivityInRemote>pinus.app.get('activities')?.get(activityId);
}
@@ -262,11 +277,24 @@ export function _getActivityById(activityId: number) {
export function _getActivitiesByType(serverId: number, type: number) {
let activityByType = pinus.app.get('activityByType')?.get(serverId)?.get(type)||[];
let activities: Map<number, ActivityInRemote> = pinus.app.get('activities');
let result: ActivityModelType[] = [];
let result: ActivityInRemote[] = [];
for(let activityId of activityByType) {
let activity = activities.get(activityId);
if(activity && activity.beginTime <= Date.now()) {
result.push(transActivityInRemoteToModelType(activity));
result.push(activity);
}
}
return result;
}
export function _getActivitiesByServerId(serverId: number) {
let activityByServerId = pinus.app.get('activityByServer')?.get(serverId)||[]
let activities: Map<number, ActivityInRemote> = pinus.app.get('activities');
let result: ActivityInRemote[] = [];
for(let activityId of activityByServerId) {
let activity = activities.get(activityId);
if(activity && activity.beginTime <= Date.now()) {
result.push(activity);
}
}
return result;

2
game-server/app/services/battleService.ts
View File

@@ -9,7 +9,7 @@ import { STATUS } from '../consts/statusCode';
import { HangUpSpdUpRecModel } from '../db/HangUpSpdUpRec';
import { TaskHero, TowerTaskRecModel, TowerTaskRecType } from '../db/TowerTaskRec';
import { Rank } from './rankService';
import { checkActivityTask, checkTask } from './taskService';
import { checkActivityTask, checkTask } from './task/taskService';
import { getRandExpedition, gameData } from '../pubUtils/data';
import { ItemInter, RewardInter } from '../pubUtils/interface';
import { getTimeFunM } from '../pubUtils/timeUtil';

2
game-server/app/services/connectorService.ts
View File

@@ -3,7 +3,7 @@
*/
import { getMails } from './mailService';
import { recentGuildMsgs, recentPrivateChatInfos, recentSysMsgs, recentWorldMsgs } from './chatService';
import { getCurTask, getPvpTask } from './taskService';
import { getCurTask, getPvpTask } from './task/taskService';
import { RoleType } from '../db/Role';
import { Application, FrontendOrBackendSession, pinus, RpcClient } from 'pinus';

2
game-server/app/services/equipService.ts
View File

@@ -3,7 +3,7 @@ import { EPlace, Stone } from "../db/Hero";
import { gameData, getRandEffectByGroupAndLevel } from "../pubUtils/data";
import { JewelType, RandSe } from '../db/Jewel';
import { getJewelRandSe } from '../pubUtils/itemUtils';
import { checkActivityTask, checkTask, checkTaskWithEplaces, checkTaskWithEplace } from './taskService';
import { checkActivityTask, checkTask, checkTaskWithEplaces, checkTaskWithEplace } from './task/taskService';
import { TASK_TYPE } from '../consts';
import { DicRandomEffectPool } from '../pubUtils/dictionary/DicRandomEffectPool';

2
game-server/app/services/guildActivity/guildActivityService.ts
View File

@@ -26,7 +26,7 @@ import { BossInstanceModel } from "../../db/BossInstance";
import { UserGuildModel } from "../../db/UserGuild";
import { raceActivityEnd } from "../timeTaskService";
import { addActive } from "../guildService";
import { checkTask, checkActivityTask } from "../taskService";
import { checkTask, checkActivityTask } from "../task/taskService";
import { ActivePlayer, GuildRecord, ServerRecordModel } from "../../db/ServerRecords";
import { Attack } from "../../domain/battleField/pvp";

2
game-server/app/services/guildService.ts
View File

@@ -16,7 +16,7 @@ import { ErrLogModel } from '../db/ErrLog';
import { DATA_NAME } from '../consts/dataName';
import { addRoleToGuildChannel } from "./chatService";
import { Rank } from "./rankService";
import { checkActivityTask, checkTask } from "./taskService";
import { checkActivityTask, checkTask } from "./task/taskService";
import { CounterModel } from "../db/Counter";
import { getAuction } from "./auctionService";
import { changeGuildActivity } from "./activity/guildPayService";

2
game-server/app/services/normalBattleService.ts
View File

@@ -8,7 +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 './taskService';
import { checkActivityTask, checkTask } from './task/taskService';
import { accomplishTask } from '../pubUtils/taskUtil';
import { RScriptRecordModel } from '../db/RScriptRecord';
import { setAp } from './actionPointService';

2
game-server/app/services/orderService.ts
View File

@@ -22,7 +22,7 @@ import { resResult } from '../pubUtils/util';
import { checkOrderWX } from './pay/weixinPay';
import { addRechargeMoney } from './activity/rechargeMoneyService';
import { addVipRechargeMoney } from './activity/vipRechargeMoneyService';
import { checkActivityTask } from './taskService';
import { checkActivityTask } from './task/taskService';
import { checkOrderALI } from './pay/aliPay';
import { getRoleOnlineInfo } from './redisService';
import { PayCallback37Data } from '../domain/sdk';

2
game-server/app/services/pvpService.ts
View File

@@ -22,7 +22,7 @@ import { Rank } from './rankService';
import { CounterModel } from '../db/Counter';
import { DicRankRewads } from '../pubUtils/dictionary/DicPvpRankReward';
import { PvpSeasonResultModel, PvpSeasonResultType } from '../db/PvpSeasonResult';
import { checkTask } from '../services/taskService';
import { checkTask } from './task/taskService';
import { sendMailByContent } from './mailService';
import { RoleRankInfo } from '../domain/rank';
import { reportTAEvent } from './sdkService';

2
game-server/app/services/refreshService.ts
View File

@@ -3,7 +3,7 @@ import { STATUS } from '../consts/statusCode';
import { resResult, shouldRefresh, shouldRefreshWeek } from '../pubUtils/util';
import { nowSeconds } from "../pubUtils/timeUtil";
// import { RoleModel } from '../db/Role';
import { refDailyTask, refDailyTaskBox } from './taskService'
import { refDailyTask, refDailyTaskBox } from './task/taskService'
// import { EVENT_STATUS, FUNCS_ID } from "../consts";
// import { startEvent } from "./eventSercive";
import * as dicParam from '../pubUtils/dicParam';

2
game-server/app/services/role/rewardService.ts
View File

@@ -13,7 +13,7 @@ import { uniq } from 'underscore';
import { EPlace, HeroModel, HeroType, HeroUpdate } from '../../db/Hero';
import { Figure } from '../../domain/dbGeneral';
import { Rank } from '../rankService';
import { pushTaskUpdate } from '../taskService';
import { pushTaskUpdate } from '../task/taskService';
import { CreateHeroParam, HeroShowParam } from '../../domain/roleField/hero';
import { HeroSkin } from '../../db/Hero';
import { errlogger } from '../../util/logger';

270
game-server/app/services/task/taskObj.ts Normal file
View File

@@ -0,0 +1,270 @@
import { pinus } from "pinus";
import { ACTIVITY_TYPE, STATUS, TASK_SUM_TYPE, TASK_TYPE } from "../../consts";
import { ActivityBuyRecordsModel } from "../../db/ActivityBuyRecords";
import { ActivityDailyChallengesModel } from "../../db/ActivityDailyChallenges";
import { ActivityGrowthModel } from "../../db/ActivityGrowth";
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 { ServerTempModel, ServerTempModelType } from "../../db/ServerTemp";
import { UserTaskRecModel } from "../../db/UserTaskRec";
import { GrowthFundData } from "../../domain/activityField/growthFundField";
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 { 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";
/**
* @class CheckTask
* @classdesc 检查某个玩家任务的达成情况
*/
export class CheckTask {
serverId: number; // 区id
roleId: string; // 玩家id
taskType: TASK_TYPE; // 任务type
roleCreateTime: number; // 玩家的创建时间
serverCreateTime: number; // 服务器的创建时间
param: TaskParam; // 检查任务时传入的参数
treasureHuntTemp: ServerTempModelType;
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.serverCreateTime = serverCreateTime;
this.param = new TaskParam();
}
/**
* @description 检查任务的主程序
*/
public async check(count: number, sid: string) {
let { taskType, roleId, serverId, roleCreateTime, serverCreateTime } = this;
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);
if (taskUpdateParam) {
let rec = await UserTaskRecModel.checkAndUpdateTask(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) });
}
}
// 检查活动任务
let activities = await getActivityByServerId(serverId);
for(let activity of activities) {
let { activityId, type: activityType } = activity;
switch(activityType) {
case ACTIVITY_TYPE.SEVEN_DAY:
case ACTIVITY_TYPE.FOURTEEN_DAY://十四天乐活动 28
case ACTIVITY_TYPE.COMMON_SEVEN_DAY://通用七天乐活动 29
{
//成长活动统计
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);
if(taskUpdateParam) {
let rec = await ActivityGrowthModel.checkAndUpdateTask(serverId, activityId, roleId, task.dayIndex, task.cellIndex, taskUpdateParam);
if(!rec) continue;
activityTaskPushMessages.push({...task, totalCount: rec.totalCount, receiveRewardCount: rec.receiveRewardCount||0, activityId, activityType: "growth" });
}
}
//今日挑战统计
let dailyChallengeTaskArray = playerData.dailyChallenge.findTaskByType(taskType);
for (let task of dailyChallengeTaskArray) {
if(dicTaskTypeDesc.sumType == TASK_SUM_TYPE.DO && task.dayIndex != playerData.today()) {
continue;
}
let taskUpdateParam = this.checkIsMatch(task.taskParamArray, count);
if(taskUpdateParam) {
let rec = await ActivityDailyChallengesModel.checkAndUpdateTask(serverId, activityId, roleId, task.dayIndex, task.cellIndex, taskUpdateParam);
if(!rec) continue;
activityTaskPushMessages.push({...task, totalCount: rec.totalCount, receiveRewardCount: rec.receiveRewardCount||0, activityId, activityType: "daily" });
}
}
break;
}
case ACTIVITY_TYPE.REFRESH_TASK:
{
// 通用的刷新任务
let taskActivity = new RefreshTaskData(activity, roleCreateTime, serverCreateTime);
let taskArray = taskActivity.findTaskByType(taskType);
for (let task of taskArray) {
let taskUpdateParam = this.checkIsMatch(task.taskParamArray, count);
if(taskUpdateParam) {
let rec = await ActivityRefreshTaskModel.checkAndUpdateTask(serverId, activityId, roleId, taskActivity.roundIndex, task.pageIndex, task.id, taskUpdateParam);
if(!rec) continue;
activityTaskPushMessages.push({...task, totalCount: rec.totalCount, receiveRewardCount: rec.receiveRewardCount||0, activityId });
}
}
break;
}
case ACTIVITY_TYPE.TREASURE_HUNT:
{
// 寻宝奇兵任务
let tempData = await this.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);
if(taskUpdateParam) {
let rec = await ActivityTreasureHuntTaskModel.checkAndUpdateTask(serverId, activityId, roleId, tempData.huntRoundIndex, task.cellIndex, taskUpdateParam);
if(!rec) continue;
activityTaskPushMessages.push({ ...task, totalCount: rec.totalCount, activityId });
}
}
}
break;
}
case ACTIVITY_TYPE.THIRTY_DAYS:
{
//30天任务统计
let thirtyDaysActivity = new ThirtyDaysData(activity, roleCreateTime, serverCreateTime);
let taskArray = thirtyDaysActivity.findTaskByType(taskType);
for (let task of taskArray) {
let taskUpdateParam = this.checkIsMatch(task.taskParamArray, count);
if(taskUpdateParam) {
let rec = await ActivityThirtyDaysModel.checkAndUpdateTask(serverId, thirtyDaysActivity.activityId, roleId, task.pageIndex, task.cellIndex, task.tab, taskUpdateParam);
if(!rec) continue;
activityTaskPushMessages.push({ ...task, totalCount: rec.totalCount, activityId });
}
}
break;
}
case ACTIVITY_TYPE.GROWTH_FUND_MAIN:
case ACTIVITY_TYPE.GROWTH_FUND_MAIN_VIP:
{
//主线成长基金
if(taskType != TASK_TYPE.BATTLE_MAIN) continue;
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:
case ACTIVITY_TYPE.GROWTH_FUND_TOWER_VIP:
{
//镇念塔成长基金
if(taskType != TASK_TYPE.BATTLE_TOWER_LV) continue;
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:
case ACTIVITY_TYPE.GROWTH_FUND_MAIN_ELITE_VIP:
{
//精英成长基金
if(taskType != TASK_TYPE.BATTLE_MAIN_ELITE) continue;
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 {
let param = this.param;
switch(this.taskType) {
case TASK_TYPE.LOGIN_SUM:
{
let today = getZeroPoint();
if (today > param.role.loginTime) {
return { inc: count }
}
}
}
}
private 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
}
}
}
class TaskParam {
role?: RoleType; // 玩家数据
warId?: number;
towerLv?: number;
public setRole(role: RoleType) {
this.role = role;
}
}

32
game-server/app/services/taskService.ts → game-server/app/services/task/taskService.ts
View File

@@ -1,20 +1,20 @@
import * as taskUtil from '../pubUtils/taskUtil';
import { RoleModel, RoleType } from '../db/Role';
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 { EPlace, HeroType } from '../db/Hero';
import { getRoleOnlineInfo } from './redisService';
import { HeroScores } from '../db/PvpHistoryOpp';
import { ItemInter } from '../pubUtils/interface';
import { UserTaskModel, UserTaskType } from '../db/UserTask';
import { UserTaskRecModel } from '../db/UserTaskRec';
import { UserTaskHistoryModel } from '../db/UserTaskHistory';
import { gameData } from '../pubUtils/data';
import { getSeconds, getZeroPointD } from '../pubUtils/timeUtil';
import { RoleStatus } from '../db/ComBattleTeam';
import { getActivities } from './activity/activityService';
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 { EPlace, HeroType } from '../../db/Hero';
import { getRoleOnlineInfo } from '../redisService';
import { HeroScores } from '../../db/PvpHistoryOpp';
import { ItemInter } from '../../pubUtils/interface';
import { UserTaskModel, UserTaskType } from '../../db/UserTask';
import { UserTaskRecModel } from '../../db/UserTaskRec';
import { UserTaskHistoryModel } from '../../db/UserTaskHistory';
import { gameData } from '../../pubUtils/data';
import { getSeconds, getZeroPointD } from '../../pubUtils/timeUtil';
import { RoleStatus } from '../../db/ComBattleTeam';
import { getActivities } from '../activity/activityService';
export async function checkTaskWithRoles(serverId: number, roleId: string, sid: string, taskType: number, roles: RoleType[]) {
for (let role of roles) {

55
shared/db/ActivityDailyChallenges.ts
View File

@@ -1,5 +1,6 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { UpdateTaskParam } from '../domain/roleField/task';
/**
* 活动系统 - 今日挑战活动
@@ -25,6 +26,8 @@ export default class Activity_Daily_Challenges extends BaseModel {
receiveRewardCount: number; // 领取奖励次数
@prop({ required: true })
data: string; // 数据信息
@prop({ required: true, type: String })
records: string[]; // 数据信息
//任务领取记录
public static async addCellRecord(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, count: number, lean = true) {
@@ -33,28 +36,48 @@ export default class Activity_Daily_Challenges 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);
} else if (param.inc) {
return await this.addTaskCount(serverId, activityId, roleId, dayIndex, cellIndex, param.inc, param.record);
}
}
//根据活动统计完成任务次数
public static async setTaskCount(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, count: number, lean = true) {
let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex, type },
{ $set: { totalCount: count } }, { upsert: true, new: true }).lean(lean);
public static async setTaskCount(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, count: number, record?: string) {
let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex },
{ $set: { totalCount: count }, $addToSet: { records: record||''} }, { upsert: true, new: true }).lean();
return result;
}
//根据活动统计完成任务次数
public static async addTaskCount(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, addCount: number, lean = true) {
let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex, type },
{ $inc: { totalCount: addCount } }, { upsert: true, new: true }).lean(lean);
public static async addTaskCount(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, addCount: number, record?: string) {
let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex },
{ $inc: { totalCount: addCount }, $addToSet: { records: record||''} }, { upsert: true, new: true }).lean();
return result;
}
//根据活动记录统计数据
public static async addTaskRecord(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, data: string,) {
let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex, type },
{ $set: { data: data } }, { upsert: true, new: true }).lean(true);
return result;
}
//根据活动id查询活动数据
public static async findData(serverId: number, activityId: number, roleId: string, lean = true) {
let result: ActivityDailyChallengesModelType[] = await ActivityDailyChallengesModel.find({ serverId, roleId, activityId }).lean(lean);
@@ -68,8 +91,8 @@ export default class Activity_Daily_Challenges extends BaseModel {
}
//查询第几天某个的活动数据
public static async findDataByCellIndex(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number) {
let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOne({ serverId, roleId, activityId, dayIndex, cellIndex, type }).lean(true);
public static async findDataByCellIndex(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number) {
let result: ActivityDailyChallengesModelType = await ActivityDailyChallengesModel.findOne({ serverId, roleId, activityId, dayIndex, cellIndex }).lean(true);
return result;
}

55
shared/db/ActivityGrowth.ts
View File

@@ -1,5 +1,6 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { UpdateTaskParam } from '../domain/roleField/task';
/**
* 活动系统 - 成长任务活动
@@ -25,6 +26,8 @@ export default class Activity_Growth extends BaseModel {
receiveRewardCount: number; // 领取奖励次数
@prop({ required: true })
data: string; // 数据信息
@prop({ required: true, type: String })
records: string[]; // 数据信息
//任务领取记录
public static async addCellRecord(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, count: number,) {
@@ -33,28 +36,48 @@ 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);
} else if (param.inc) {
return await this.addTaskCount(serverId, activityId, roleId, dayIndex, cellIndex, param.inc, param.record);
}
}
//根据活动统计完成任务次数
public static async setTaskCount(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, count: number, lean = true) {
let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex, type },
{ $set: { totalCount: count } }, { upsert: true, new: true }).lean(lean);
public static async setTaskCount(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, count: number, record?: string) {
let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex },
{ $set: { totalCount: count }, $addToSet: { records: record||'' } }, { upsert: true, new: true }).lean();
return result;
}
//根据活动统计完成任务次数
public static async addTaskCount(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, addCount: number, lean = true) {
let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex, type },
{ $inc: { totalCount: addCount } }, { upsert: true, new: true }).lean(lean);
public static async addTaskCount(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, addCount: number, record?: string) {
let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex },
{ $inc: { totalCount: addCount }, $addToSet: { records: record||'' } }, { upsert: true, new: true }).lean();
return result;
}
//根据活动记录统计数据
public static async addTaskRecord(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number, data: string,) {
let result: ActivityGrowthModelType = await ActivityGrowthModel.findOneAndUpdate({ serverId, roleId, activityId, dayIndex, cellIndex, type },
{ $set: { data: data } }, { upsert: true, new: true }).lean(true);
return result;
}
//根据活动id查询活动数据
public static async findData(serverId: number, activityId: number, roleId: string, lean = true) {
let result: ActivityGrowthModelType[] = await ActivityGrowthModel.find({ serverId, roleId, activityId }).lean(lean);
@@ -68,8 +91,8 @@ export default class Activity_Growth extends BaseModel {
}
//查询第几天某个的活动数据
public static async findDataByCellIndex(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number, type: number,) {
let result: ActivityGrowthModelType = await ActivityGrowthModel.findOne({ serverId, roleId, activityId, dayIndex, cellIndex, type }).lean(true);
public static async findDataByCellIndex(serverId: number, activityId: number, roleId: string, dayIndex: number, cellIndex: number) {
let result: ActivityGrowthModelType = await ActivityGrowthModel.findOne({ serverId, roleId, activityId, dayIndex, cellIndex }).lean(true);
return result;
}

49
shared/db/ActivityRefreshTask.ts
View File

@@ -1,5 +1,6 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { UpdateTaskParam } from '../domain/roleField/task';
/**
* 活动系统 - 通用的刷新任务（分页，可刷新，限制领取次数）
@@ -27,6 +28,8 @@ export default class Activity_Refresh_Task extends BaseModel {
receiveRewardCount: number; // 领取奖励次数
@prop({ required: true })
data: string; // 数据信息
@prop({ required: true, type: String })
records: string[]; // 数据信息
//任务领取记录
public static async addReceiveRecord(serverId: number, activityId: number, roleId: string, roundIndex: number, pageIndex: number, id: number, type: number, count: number) {
@@ -35,17 +38,47 @@ export default class Activity_Refresh_Task extends BaseModel {
return result;
}
// 更新任务
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);
} else if (param.inc) {
return await this.addTaskCount(serverId, activityId, roleId, roundIndex, pageIndex, id, param.inc, param.record);
}
}
//根据活动统计完成任务次数
public static async setTaskCount(serverId: number, activityId: number, roleId: string, roundIndex: number, pageIndex: number, id: number, type: number, count: number, lean = true) {
let result: ActivityRefreshTaskModelType = await ActivityRefreshTaskModel.findOneAndUpdate({ serverId, roleId, activityId, roundIndex, pageIndex, id, type },
{ $set: { totalCount: count } }, { upsert: true, new: true }).lean(lean);
public static async setTaskCount(serverId: number, activityId: number, roleId: string, roundIndex: number, pageIndex: number, id: number, count: number, record?: string) {
let result: ActivityRefreshTaskModelType = await ActivityRefreshTaskModel.findOneAndUpdate({ serverId, roleId, activityId, roundIndex, pageIndex, id },
{ $set: { totalCount: count }, $setOnInsert: { records: record||'' } }, { upsert: true, new: true }).lean();
return result;
}
//根据活动统计完成任务次数
public static async addTaskCount(serverId: number, activityId: number, roleId: string, roundIndex: number, pageIndex: number, id: number, type: number, addCount: number, lean = true) {
let result: ActivityRefreshTaskModelType = await ActivityRefreshTaskModel.findOneAndUpdate({ serverId, roleId, activityId, roundIndex, pageIndex, id, type },
{ $inc: { totalCount: addCount } }, { upsert: true, new: true }).lean(lean);
public static async addTaskCount(serverId: number, activityId: number, roleId: string, roundIndex: number, pageIndex: number, id: number, count: number, record?: string) {
let result: ActivityRefreshTaskModelType = await ActivityRefreshTaskModel.findOneAndUpdate({ serverId, roleId, activityId, roundIndex, pageIndex, id },
{ $inc: { totalCount: count }, $setOnInsert: { records: record||'' } }, { upsert: true, new: true }).lean();
return result;
}
@@ -64,8 +97,8 @@ export default class Activity_Refresh_Task extends BaseModel {
}
//查询活动数据
public static async findDataById(serverId: number, activityId: number, roleId: string, roundIndex: number, pageIndex: number, id: number, type: number) {
let result: ActivityRefreshTaskModelType = await ActivityRefreshTaskModel.findOne({ serverId, roleId, activityId, roundIndex, pageIndex, id, type }).lean(true);
public static async findDataById(serverId: number, activityId: number, roleId: string, roundIndex: number, pageIndex: number, id: number) {
let result: ActivityRefreshTaskModelType = await ActivityRefreshTaskModel.findOne({ serverId, roleId, activityId, roundIndex, pageIndex, id }).lean(true);
return result;
}

71
shared/db/ActivityThirtyDays.ts
View File

@@ -1,5 +1,6 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { UpdateTaskParam } from '../domain/roleField/task';
/**
* 30天目标活动
@@ -27,10 +28,8 @@ export default class Activity_Thirty_Days extends BaseModel {
isReceive: boolean; // 是否领取过奖励
@prop({ required: true })
data: string; // 数据信息
@prop({ required: true })
isPush: boolean; // 推送过消息
@prop({ required: true, type: String })
records: string[]; // 数据信息
//添加领取记录
public static async addRecord(serverId: number, activityId: number, roleId: string, pageIndex: number, cellIndex: number, tab: number) {
@@ -39,13 +38,6 @@ export default class Activity_Thirty_Days extends BaseModel {
return result;
}
//根据活动统计完成任务次数
public static async addTaskCount(serverId: number, activityId: number, roleId: string, pageIndex: number, cellIndex: number, tab: number, type: number, addCount: number, lean = true) {
let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOneAndUpdate({ serverId, roleId, activityId, pageIndex, cellIndex, tab, type },
{ $inc: { totalCount: addCount } }, { upsert: true, new: true }).lean(lean);
return result;
}
//根据活动记录统计数据
public static async addTaskRecord(serverId: number, activityId: number, roleId: string, pageIndex: number, cellIndex: number, tab: number, type: number, data: string,) {
let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOneAndUpdate({ serverId, roleId, activityId, pageIndex, cellIndex, tab, type },
@@ -53,13 +45,6 @@ export default class Activity_Thirty_Days extends BaseModel {
return result;
}
//根据活动统计完成任务次数
public static async setTaskCount(serverId: number, activityId: number, roleId: string, pageIndex: number, cellIndex: number, tab: number, type: number, count: number, lean = true) {
let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOneAndUpdate({ serverId, roleId, activityId, pageIndex, cellIndex, tab, type },
{ $set: { totalCount: count } }, { upsert: true, new: true }).lean(lean);
return result;
}
//推送标记
public static async pushMessage(serverId: number, activityId: number, roleId: string, pageIndex: number, cellIndex: number, tab: number, type: number) {
let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOneAndUpdate({ serverId, roleId, activityId, pageIndex, cellIndex, tab, type },
@@ -79,15 +64,55 @@ export default class Activity_Thirty_Days extends BaseModel {
return result;
}
// 更新任务
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);
} else if (param.inc) {
return await this.addTaskCount(serverId, activityId, roleId, pageIndex, cellIndex, tab, param.inc, param.record);
}
}
//查询第*页的某个的活动数据
public static async findDataByCellIndex(serverId: number, activityId: number, roleId: string, pageIndex: number, cellIndex: number, tab: number, type: number,) {
let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOne({ serverId, roleId, activityId, pageIndex, cellIndex, tab, type }).lean(true);
public static async findDataByCellIndex(serverId: number, activityId: number, roleId: string, pageIndex: number, cellIndex: number, tab: number,) {
let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOne({ serverId, roleId, activityId, pageIndex, cellIndex, tab }).lean(true);
return result;
}
//删除活动领取记录
public static async deleteActivity(serverId: number, activityId: number, roleId: string, pageIndex: number, cellIndex: number) {
await ActivityThirtyDaysModel.deleteMany({ serverId, roleId, activityId, pageIndex, cellIndex });
//根据活动统计完成任务次数
public static async addTaskCount(serverId: number, activityId: number, roleId: string, pageIndex: number, cellIndex: number, tab: number, count: number, record?: string) {
let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOneAndUpdate({ serverId, roleId, activityId, pageIndex, cellIndex, tab },
{ $inc: { totalCount: count }, $addToSet: { records: record||'' } }, { 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) {
let result: ActivityThirtyDaysModelType = await ActivityThirtyDaysModel.findOneAndUpdate({ serverId, roleId, activityId, pageIndex, cellIndex, tab },
{ $set: { totalCount: count }, $addToSet: { records: record||'' } }, { upsert: true, new: true }).lean();
return result;
}
}

43
shared/db/ActivityTreasureHuntTask.ts
View File

@@ -1,5 +1,6 @@
import ActivityGrowth from './ActivityGrowth';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { UpdateTaskParam } from '../domain/roleField/task';
/**
* 活动系统 - 寻宝骑兵-备战任务
@@ -27,6 +28,48 @@ export default class Activity_Treasure_Hunt_Task extends ActivityGrowth {
return result;
}
// 更新任务
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);
} else if (param.inc) {
return await this.addTaskCount(serverId, activityId, roleId, roundIndex, cellIndex, param.inc, param.record);
}
}
//根据活动统计完成任务次数
public static async setTaskCount(serverId: number, activityId: number, roleId: string, roundIndex: number, cellIndex: number, count: number, record?: string) {
let result: ActivityTreasureHuntTaskModelType = await ActivityTreasureHuntTaskModel.findOneAndUpdate({ serverId, roleId, activityId, roundIndex, cellIndex },
{ $set: { totalCount: count }, $addToSet: { records: record||'' } }, { 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) {
let result: ActivityTreasureHuntTaskModelType = await ActivityTreasureHuntTaskModel.findOneAndUpdate({ serverId, roleId, activityId, roundIndex, cellIndex },
{ $inc: { totalCount: count }, $addToSet: { records: record||'' } }, { upsert: true, new: true }).lean();
return result;
}
//查询活动数据
public static async findDataByCellIndex(serverId: number, activityId: number, roleId: string, roundIndex: number, cellIndex: number) {
let result: ActivityTreasureHuntTaskModelType = await ActivityTreasureHuntTaskModel.findOne({ serverId, roleId, activityId, roundIndex, cellIndex }).lean(true);

43
shared/db/UserTaskRec.ts
View File

@@ -3,6 +3,7 @@ import { index, getModelForClass, prop, DocumentType, modelOptions } from '@type
import { TASK_FUN_TYPE } from '../consts';
import { genCode } from '../pubUtils/util';
import { getZeroPointD } from '../pubUtils/timeUtil';
import { UpdateTaskParam } from '../domain/roleField/task';
/**
* 玩家任务记录表
@@ -46,19 +47,53 @@ export default class UserTaskRec extends BaseModel {
}
}
public static async setTaskRec(roleId: string, type: number, taskType: number, group: string, count: number) {
public static async setTaskRec(roleId: string, type: number, taskType: number, group: string, count: number, record?: string) {
let condition = this.getRefreshCondition(type);
let rec: UserTaskRecType = await UserTaskRecModel.findOneAndUpdate({ roleId, group, taskType, ...condition }, { $setOnInsert: { code: genCode(8), received: [] }, $set: { count } }, { new: true, upsert: true }).lean();
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();
return rec;
}
public static async incTaskRec(roleId: string, type: number, taskType: number, group: string, count: number) {
public static async incTaskRec(roleId: string, type: number, taskType: number, group: string, count: number, record?: string) {
let condition = this.getRefreshCondition(type);
let rec: UserTaskRecType = await UserTaskRecModel.findOneAndUpdate({ roleId, group, taskType, ...condition }, { $setOnInsert: { code: genCode(8), received: [] }, $inc: { count } }, { new: true, upsert: true }).lean();
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();
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);
} else if (param.inc) {
return await this.incTaskRec(roleId, type, taskType, group, param.inc, param.record);
}
}
public static async checkHistoryAndSetTaskRec(roleId: string, type: number, taskType: number, group: string, count: number) {
let rec: UserTaskRecType = await UserTaskRecModel.findByRoleAndGroup(roleId, type, taskType, group);

2
shared/domain/activityField/activityField.ts
View File

@@ -135,7 +135,7 @@ export class ActivityInRemote {
}
}
export function transActivityInRemoteToModelType(activity: ActivityInRemote) {
export function transActivityInRemoteToModelType(activity: ActivityInRemote): ActivityModelType {
if(!activity) return null;
return {
...activity,

4
shared/domain/activityField/growthFundField.ts
View File

@@ -164,8 +164,8 @@ export class GrowthFundData extends ActivityBase {
}
}
constructor(activityData: ActivityModelType, createTime: number) {
super(activityData, createTime)
constructor(activityData: ActivityModelType, createTime: number, serverTime?: number) {
super(activityData, createTime, serverTime)
this.initData(activityData.data)
}
}

4
shared/domain/activityField/refreshTaskField.ts
View File

@@ -128,8 +128,8 @@ export class RefreshTaskData extends ActivityBase {
}
}
constructor(activityData: ActivityModelType, createTime: number) {
super(activityData, createTime)
constructor(activityData: ActivityModelType, createTime: number, serverTime?: number) {
super(activityData, createTime, serverTime)
this.initData(activityData.data)
}
}

8
shared/domain/activityField/sevenDaysField.ts
View File

@@ -5,7 +5,7 @@ import { ActivityGrowthModelType } from '../../db/ActivityGrowth';
import { ActivityGrowthPointModelType } from '../../db/ActivityGrowthPoint';
import { HeroType } from '../../db/Hero';
import { RoleModel } from '../../db/Role';
import { splitString } from '../../pubUtils/util';
import { parseNumberList, splitString } from '../../pubUtils/util';
import { ActivityDailyGiftsModelType } from '../../db/ActivityDailyGifts';
import { parseResStr } from '../../pubUtils/util';
import { ConsumeResParam } from '../activityField/consumeField';
@@ -18,6 +18,7 @@ export class SevenDaysDailyItem {
name: string; // 任务名称
taskType: number; // 任务类型 dic_zyz_taskType.json
taskParam: string; //任务数据 dic_zyz_taskType.json
taskParamArray: number[];
condition: number; //任务数据条件 dic_zyz_taskType.jsonT
reward: string; // 任务奖励，格式:1&3&1(类型&id&数量) 类型定义:1.英雄，2.物品
skip: string; // 跳转
@@ -35,6 +36,7 @@ export class SevenDaysDailyItem {
this.reward = data.reward;
this.skip = data.skip;
this.taskParamArray = parseNumberList(data.taskParam);
this.totalCount = 0;
this.receiveRewardCount = 0;
}
@@ -324,8 +326,8 @@ export class SevenDaysData extends ActivityBase {
this.dailyChallenge = new SevenDaysDailyChallengesData(objData.dailyChallenge)
}
constructor(activityData: ActivityModelType, createTime: number) {
super(activityData, createTime)
constructor(activityData: ActivityModelType, createTime: number, serverCreateTime?: number) {
super(activityData, createTime, serverCreateTime)
this.initData(activityData.data)
}
}

18
shared/domain/activityField/thirtyDaysField.ts
View File

@@ -118,20 +118,6 @@ export class ThirtyDaysData extends ActivityBase {
pointRewardList: Array<ThirtyDaysPointItem> = [];//点数兑换奖励
totalPoint: number = 0;//总共点数
//未完成的任务
public findUncompleteTaskByType(type: number): ThirtyDaysItem[] {
let task = [];
for (let i = 0; i < this.list.length; i++) {
let items = this.list[i].item;
for (let itemData of items) {
if (itemData.taskType == type && !itemData.isComplete) {
task.push(itemData);
}
}
}
return task;
}
public findTaskByType(type: number) {
let task = [];
for (let i = 0; i < this.list.length; i++) {
@@ -256,8 +242,8 @@ export class ThirtyDaysData extends ActivityBase {
}
}
constructor(activityData: ActivityModelType, createTime: number) {
super(activityData, createTime)
constructor(activityData: ActivityModelType, createTime: number, serverTime?: number) {
super(activityData, createTime, serverTime)
this.initData(activityData.data)
}
}

8
shared/domain/activityField/treasureHuntField.ts
View File

@@ -4,7 +4,7 @@ import { ActivityTreasureHuntShopModelType } from '../../db/ActivityTreasureHunt
import { ActivityTreasureHuntTaskModelType } from '../../db/ActivityTreasureHuntTask';
import { ActivityTreasureHuntTreasureShopModelType } from '../../db/ActivityTreasureHuntTreasureShop';
import { ActivityTreasureHuntFirstPageModelType } from '../../db/ActivityTreasureHuntFirstPage';
import { splitString } from '../../pubUtils/util';
import { parseNumberList, splitString } from '../../pubUtils/util';
import { ActivityBase } from './activityField';
@@ -142,6 +142,7 @@ export class TreasureHuntTaskItem {
fragment: number; //碎片
skip: string;
taskParamArray: number[]; // 任务参数
totalCount: number = 0; //任务统计
isReceive: boolean = false; //是否领取奖励
@@ -150,6 +151,7 @@ export class TreasureHuntTaskItem {
this.name = data.name;
this.taskType = data.taskType;
this.taskParam = data.taskParam;
this.taskParamArray = parseNumberList(data.taskParamArray);
this.condition = data.condition;
this.reward = data.reward;
this.fragment = data.fragment;
@@ -339,8 +341,8 @@ export class TreasureHuntData extends ActivityBase {
}
}
constructor(activityData: ActivityModelType, createTime: number) {
super(activityData, createTime)
constructor(activityData: ActivityModelType, createTime: number, sererTime?: number) {
super(activityData, createTime, sererTime);
this.initData(activityData.data)
}
}

8
shared/domain/roleField/task.ts
View File

@@ -38,4 +38,12 @@ export class TaskListReturn {
id: number; // 任务id
count: number; // 达成次数
received: boolean; // 是否领取
}
export interface UpdateTaskParam {
inc?: number; // 直接增
set?: number; // 直接设
record?: string; // 检查是否有这条记录、没有的话增
max?: number; // 检查是否是最大的，不是的话更
min?: number; // 检查是否是最小的，不是的话更
}

5
shared/pubUtils/taskUtil.ts
View File

@@ -630,10 +630,11 @@ function checkRecResult(rec: UserTaskRecType, id: number) {
*
*/
export async function accomplishTask(serverId: number, roleId: string, taskType: TASK_TYPE, count: number, parma?: any, activities?: ActivityInRemote[]) {
// console.log('accomplishTask', roleId, taskType, count, JSON.stringify(parma))
let dicTaskType = gameData.taskDescByType.get(taskType);
let pushMessage = [];
let serverInfo = await ServerlistModel.findByServerId(serverId);
/* let serverInfo = await ServerlistModel.findByServerId(serverId);
if (!serverInfo) return [];
let { activityGroupId } = serverInfo;
let findActivitiesByTypes = async (types: number[]) => {
@@ -859,6 +860,7 @@ export async function accomplishTask(serverId: number, roleId: string, taskType:
}
}
}
// console.log('***** thirtyDay after', Date.now());
@@ -990,6 +992,7 @@ export async function accomplishTask(serverId: number, roleId: string, taskType:
}
}
// console.log('***** growthFundElite after', Date.now());
*/
return pushMessage;
}