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

任务：修改taskType

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