486 lines
19 KiB
TypeScript
486 lines
19 KiB
TypeScript
import { gameData } from './data';
|
||
import { DicTask } from './dictionary/DicTask';
|
||
import { TASK_TYPE, ABI_STAGE, WAR_TYPE, GUILD_JOB, TASK_FUN_TYPE, FUNCS_ID } from '../consts';
|
||
import { UserTaskRecModel, UserTaskRecType } from '../db/UserTaskRec'
|
||
import { RoleType, RoleModel } from '../db/Role';
|
||
import { TaskParam, TaskListReturn } from '../domain/roleField/task';
|
||
import { getTodayZeroPoint } from './timeUtil';
|
||
import { HeroType } from '../db/Hero';
|
||
import { EquipType, EquipModel } from '../db/Equip';
|
||
import { ItemInter } from './interface';
|
||
|
||
export async function checkTaskWithRoles(taskType: number, roles: RoleType[], funcs?: number[]) {
|
||
let pushMessage = new Array<TaskListReturn>();
|
||
for(let role of roles) {
|
||
if(role) {
|
||
let singlePush = await checkTaskWithRole(role.roleId, taskType, role, funcs);
|
||
pushMessage.concat(singlePush);
|
||
}
|
||
}
|
||
return pushMessage
|
||
}
|
||
|
||
export async function checkTaskWithRole(roleId: string, taskType: number, role: RoleType, funcs?: number[]) {
|
||
let pushMessage = new Array<TaskListReturn>();
|
||
|
||
if(taskType == TASK_TYPE.LOGIN_SUM)
|
||
{
|
||
let today = getTodayZeroPoint();
|
||
if(today > role.loginTime) {
|
||
pushMessage = await checkTask(roleId, taskType, 1, true, {}, funcs);
|
||
}
|
||
}
|
||
else if (taskType == TASK_TYPE.LOGIN_SERIES)
|
||
{
|
||
let today = getTodayZeroPoint();
|
||
if(today > role.loginTime) {
|
||
if(today - role.loginTime > 24 * 60 * 60 ) {
|
||
pushMessage = await checkTask(roleId, taskType, 0, false, {}, funcs);
|
||
} else {
|
||
pushMessage = await checkTask(roleId, taskType, 1, true, {}, funcs);
|
||
}
|
||
}
|
||
}
|
||
else if (taskType == TASK_TYPE.FRIEND_NUM)
|
||
{
|
||
let { friendCnt } = role;
|
||
pushMessage = await checkTask(roleId, taskType, friendCnt, false, {}, funcs);
|
||
}
|
||
|
||
return pushMessage
|
||
}
|
||
|
||
|
||
export async function checkTaskWithHeroes(roleId: string, taskType: number, heroes: HeroType[], funcs?: number[]) {
|
||
let pushMessage = new Array<TaskListReturn>();
|
||
for(let hero of heroes) {
|
||
let singlePush = await checkTaskWithHero(roleId, taskType, hero, [], funcs);
|
||
pushMessage.concat(singlePush);
|
||
}
|
||
return pushMessage
|
||
}
|
||
|
||
export async function checkTaskWithHero(roleId: string, taskType: number, hero: HeroType, args: number[] = [], funcs?: number[]) {
|
||
let pushMessage = new Array<TaskListReturn>();
|
||
if(taskType == TASK_TYPE.HERO_STAR_UP)
|
||
{
|
||
let dicHero = gameData.hero.get(hero.hid);
|
||
let starUp = hero.star - dicHero.initialStars;
|
||
if(hero.colorStar > 1) starUp += hero.colorStar - 1;
|
||
pushMessage = await checkTask(roleId, taskType, 1, true, { star: starUp }, funcs)
|
||
}
|
||
else if(taskType == TASK_TYPE.HERO_QUALITY)
|
||
{
|
||
let dicHero = gameData.hero.get(hero.hid);
|
||
pushMessage = await checkTask(roleId, taskType, 1, true, { quality: dicHero.quality }, funcs);
|
||
}
|
||
else if (taskType == TASK_TYPE.HERO_QUALITY_STAR_UP)
|
||
{
|
||
let dicHero = gameData.hero.get(hero.hid);
|
||
pushMessage = await checkTask(roleId, taskType, 1, true, { quality: dicHero.quality, star: hero.star }, funcs);
|
||
}
|
||
else if (taskType == TASK_TYPE.HERO_LV)
|
||
{
|
||
pushMessage = await checkTask(roleId, taskType, 1, true, { lv: hero.lv }, funcs);
|
||
}
|
||
else if (taskType == TASK_TYPE.HERO_TRAIN)
|
||
{
|
||
let dicHero = gameData.hero.get(hero.hid);
|
||
let initGrage = gameData.job.get(dicHero.jobid).grade;
|
||
let curGrade = gameData.job.get(hero.job).grade;
|
||
let count = (curGrade - initGrage) * (ABI_STAGE.END - ABI_STAGE.START) + (hero.jobStage - ABI_STAGE.START); // 训练次数
|
||
pushMessage = await checkTask(roleId, taskType, 1, true, { count }, funcs);
|
||
}
|
||
else if (taskType == TASK_TYPE.HERO_QUALITY_UP)
|
||
{
|
||
let dicHero = gameData.hero.get(hero.hid);
|
||
if(hero.quality - dicHero.quality == 1) { // 每个武将升品算一次
|
||
pushMessage = await checkTask(roleId, taskType, 1, true, {}, funcs);
|
||
}
|
||
}
|
||
else if (taskType == TASK_TYPE.HERO_STAGE_UP)
|
||
{
|
||
let dicHero = gameData.hero.get(hero.hid);
|
||
let initGrage = gameData.job.get(dicHero.jobid).grade;
|
||
let curGrade = gameData.job.get(hero.job).grade;
|
||
let count = curGrade - initGrage; // 进阶次数
|
||
pushMessage = await checkTask(roleId, taskType, 1, true, { count }, funcs);
|
||
}
|
||
else if (taskType == TASK_TYPE.HERO_FAVOUR_LV)
|
||
{
|
||
pushMessage = await checkTask(roleId, taskType, 1, true, { favourLv: hero.favourLv }, funcs)
|
||
}
|
||
else if (taskType == TASK_TYPE.EQUIP_BY_HERO)
|
||
{
|
||
// arg[0] 1：穿上 -1：脱下
|
||
let { ePlace } = hero;
|
||
let count = ePlace.filter(cur => cur.equip).length;
|
||
pushMessage = await checkTask(roleId, taskType, args[0], true, { count, isPutOn: args[0] }, funcs);
|
||
}
|
||
else if (taskType == TASK_TYPE.EQUIP_STRENGTHEN)
|
||
{
|
||
// args: 依次为原先的装备的强化等级
|
||
let { ePlace } = hero;
|
||
let index = 0;
|
||
for(let { lv } of ePlace) {
|
||
let p = await checkTask(roleId, taskType, 1, true, { oldLv: args[index++], lv }, funcs);
|
||
pushMessage = pushMessage.concat(p);
|
||
}
|
||
}
|
||
|
||
return pushMessage
|
||
}
|
||
|
||
|
||
export async function checkTaskWithEquip(roleId: string, taskType: number, equip: EquipType, args: number[] = [], funcs?: number[]) {
|
||
let pushMessage = new Array<TaskListReturn>();
|
||
if(taskType == TASK_TYPE.EQUIP_QUALITY)
|
||
{
|
||
// args[0] 1：装上 -1：脱下
|
||
let dicGood = gameData.goods.get(equip.id);
|
||
pushMessage = await checkTask(roleId, taskType, args[0], true, { quality: dicGood.quality }, funcs)
|
||
}
|
||
else if (taskType == TASK_TYPE.EQUIP_JEWEL)
|
||
{
|
||
// args[0] 原来镶嵌了多少宝石
|
||
let { holes } = equip;
|
||
let jewelCount = holes.filter(cur => cur.jewel > 0).length;
|
||
if(jewelCount > 0 && args[0] <= 0) { // 原来没有，镶嵌上了
|
||
pushMessage = await checkTask(roleId, taskType, 1, true, {}, funcs);
|
||
} else if (jewelCount <= 0 && args[0] > 0) { // 原来镶嵌着，现在没了
|
||
pushMessage = await checkTask(roleId, taskType, -1, true, {}, funcs);
|
||
}
|
||
}
|
||
else if (taskType == TASK_TYPE.EQUIP_COMPOSE_SUIT)
|
||
{
|
||
let dicGood = gameData.goods.get(equip.id);
|
||
if(dicGood.suitId) {
|
||
pushMessage = await checkTask(roleId, taskType, 1, true, {}, funcs);
|
||
}
|
||
}
|
||
else if (taskType == TASK_TYPE.EQUIP_SUIT)
|
||
{
|
||
let dicGood = gameData.goods.get(equip.id);
|
||
if(dicGood.suitId) {
|
||
let suit = gameData.suit.get(dicGood.suitId);
|
||
let equips = await EquipModel.getEquipsByIds(roleId, suit.tireInfo);
|
||
let everyEquip = new Map<number, number>();
|
||
for(let equip of equips) {
|
||
if(everyEquip.has(equip.id)) {
|
||
everyEquip.set(equip.id, everyEquip.get(equip.id) + 1);
|
||
} else {
|
||
everyEquip.set(equip.id, 1);
|
||
}
|
||
}
|
||
let minCount = 0, curCount = 0;
|
||
for(let id of suit.tireInfo) {
|
||
let count = everyEquip.get(id)||0;
|
||
if(minCount > count) minCount = count;
|
||
if(id == equip.id) curCount = count;
|
||
}
|
||
if(curCount == minCount) {
|
||
pushMessage = await checkTask(roleId, taskType, 1, true, {}, funcs);
|
||
}
|
||
}
|
||
}
|
||
else if (taskType == TASK_TYPE.EQUIP_JEWEL_SUM)
|
||
{
|
||
// args[0] 原来镶嵌了多少宝石
|
||
let { holes } = equip;
|
||
let jewelCount = holes.filter(cur => cur.jewel > 0).length;
|
||
pushMessage = await checkTask(roleId, taskType, jewelCount - args[0], true, {}, funcs);
|
||
}
|
||
return pushMessage
|
||
}
|
||
|
||
export async function checkTaskWithArgs(roleId: string, taskType: number, args: number[], funcs?: number[]) {
|
||
let pushMessage = new Array<TaskListReturn>();
|
||
|
||
if(taskType == TASK_TYPE.ROLE_SCHOOL_PUT_HERO)
|
||
{
|
||
let [ hid, preHid ] = args;
|
||
if(hid > 0 && preHid <= 0) { // 放置
|
||
pushMessage = await checkTask(roleId, taskType, 1, true, {}, funcs);
|
||
} else if (hid <= 0 && preHid > 0) { // 卸下
|
||
pushMessage = await checkTask(roleId, taskType, -1, true, {}, funcs);
|
||
}
|
||
}
|
||
else if (taskType == TASK_TYPE.EQUIP_JEWEL_STAGE)
|
||
{
|
||
// args 装上的， 卸下的
|
||
let [putOnJewel, putOffJewel] = args;
|
||
if(putOnJewel > 0) {
|
||
let dicGood = gameData.goods.get(putOnJewel);
|
||
let push = await checkTask(roleId, taskType, 1, true, { stage: dicGood.lvLimited }, funcs);
|
||
pushMessage.concat(push);
|
||
}
|
||
if(putOffJewel > 0) {
|
||
let dicGood = gameData.goods.get(putOffJewel);
|
||
let push = await checkTask(roleId, taskType, -1, true, { stage: dicGood.lvLimited }, funcs);
|
||
pushMessage.concat(push);
|
||
}
|
||
}
|
||
else if (taskType == TASK_TYPE.CHAT)
|
||
{
|
||
// args[0] 聊天type 1-系统 2-世界 3-军团 4-组队 5-私聊
|
||
pushMessage = await checkTask(roleId, taskType, 1, true, { chatType: args[0] }, funcs)
|
||
}
|
||
|
||
return pushMessage
|
||
}
|
||
|
||
export async function checkTaskWithWar(roleId: string, taskType: number, warId: number, heroes: number[], count: number, star: number, funcs?: number[]) {
|
||
let dicWar = gameData.war.get(warId);
|
||
let pushMessage = new Array<TaskListReturn>();
|
||
if(taskType == TASK_TYPE.BATTLE_WITH_HERO)
|
||
{
|
||
pushMessage = await checkTask(roleId, taskType, count, true, { warId, heroes }, funcs);
|
||
}
|
||
else if (taskType == TASK_TYPE.BATTLE_MAIN)
|
||
{
|
||
if(dicWar.warType == WAR_TYPE.NORMAL) {
|
||
pushMessage = await checkTask(roleId, taskType, count, true, { warId }, funcs);
|
||
}
|
||
}
|
||
else if (taskType == TASK_TYPE.BATTLE_MAIN_SWEEP)
|
||
{
|
||
if(dicWar.warType == WAR_TYPE.NORMAL) {
|
||
pushMessage = await checkTask(roleId, taskType, count, true, {}, funcs);
|
||
}
|
||
}
|
||
else if (taskType == TASK_TYPE.BATTLE_DAILY_STAR)
|
||
{
|
||
if(dicWar.warType == WAR_TYPE.DAILY) {
|
||
pushMessage = await checkTask(roleId, taskType, count, true, { warId, star }, funcs);
|
||
}
|
||
}
|
||
else if (taskType == TASK_TYPE.BATTLE_DAILY)
|
||
{
|
||
if(dicWar.warType == WAR_TYPE.DAILY) {
|
||
pushMessage = await checkTask(roleId, taskType, count, true, { dailyType: dicWar.dailyType }, funcs)
|
||
}
|
||
}
|
||
else if (taskType == TASK_TYPE.BATTLE_DUNGEON)
|
||
{
|
||
if(dicWar.warType == WAR_TYPE.MYSTERY||dicWar.warType == WAR_TYPE.MYSTERY_ELITE) {
|
||
pushMessage = await checkTask(roleId, taskType, count, true, {}, funcs);
|
||
}
|
||
}
|
||
else if (taskType == TASK_TYPE.BATTLE_DUNGEON_WAR)
|
||
{
|
||
if(dicWar.warType == WAR_TYPE.MYSTERY||dicWar.warType == WAR_TYPE.MYSTERY_ELITE) {
|
||
pushMessage = await checkTask(roleId, taskType, count, true, { warId }, funcs);
|
||
}
|
||
}
|
||
else if (taskType == TASK_TYPE.BATTLE_TOWER)
|
||
{
|
||
if(dicWar.warType == WAR_TYPE.TOWER) {
|
||
pushMessage = await checkTask(roleId, taskType, count, true, {}, funcs);
|
||
}
|
||
}
|
||
else if (taskType == TASK_TYPE.BATTLE_VESTIGE)
|
||
{
|
||
if(dicWar.warType == WAR_TYPE.VESTIGE) {
|
||
pushMessage = await checkTask(roleId, taskType, count, true, {}, funcs);
|
||
}
|
||
}
|
||
else if (taskType == TASK_TYPE.BATTLE_EXPEDITION)
|
||
{
|
||
if(dicWar.warType == WAR_TYPE.EXPEDITION) {
|
||
pushMessage = await checkTask(roleId, taskType, count, true, {}, funcs);
|
||
}
|
||
}
|
||
return pushMessage
|
||
}
|
||
|
||
|
||
export async function checkTaskWithGoods(roleId: string, taskType: number, goods: ItemInter[], funcs?: number[]) {
|
||
let pushMessage = new Array<TaskListReturn>();
|
||
if(taskType == TASK_TYPE.COM_BATTLE_DROP)
|
||
{
|
||
for(let { id, count } of goods) {
|
||
let push = await checkTask(roleId, taskType, count, true, { gid: id }, funcs);
|
||
pushMessage.concat(push);
|
||
}
|
||
}
|
||
return pushMessage
|
||
}
|
||
|
||
// 根据taskType判断有哪些任务需要check的
|
||
export async function checkTask(roleId: string, taskType: number, count: number, isInc: boolean, param: TaskParam, funcs?: number[]) {
|
||
let tasks = gameData.taskType.get(taskType)||[];
|
||
let pushMessage = new Array<TaskListReturn>();
|
||
let groups = new Map<number, { task0: DicTask, tasks: DicTask[] }>();
|
||
for(let dicTask of tasks) {
|
||
if(!groups.has(dicTask.group)) {
|
||
groups.set(dicTask.group, { task0: dicTask, tasks: new Array<DicTask>() });
|
||
}
|
||
groups.get(dicTask.group).tasks.push(dicTask);
|
||
}
|
||
if(!funcs) {
|
||
let role = await RoleModel.findByRoleId(roleId, 'funcs');
|
||
funcs = role.funcs||[];
|
||
}
|
||
|
||
for(let [ group, { task0, tasks } ] of groups) {
|
||
let rec = await checkTaskRec(roleId, group, task0, count, isInc, param, funcs);
|
||
if(rec) {
|
||
for(let dicTask of tasks) {
|
||
if(checkRecResult(rec, dicTask.id, dicTask.condition)) {
|
||
let received = rec.received||[];
|
||
pushMessage.push({ type: dicTask.type, id: dicTask.id, count: rec.count, received: received.includes(dicTask.id) });
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return pushMessage;
|
||
}
|
||
|
||
// 检查各项任务是否达成，达成了就保存到数据库
|
||
export async function checkTaskRec(roleId: string, group: number, dicTask: DicTask, count: number, isInc: boolean, param: TaskParam, funcs: number[] ) {
|
||
let { type, taskParam, taskType } = dicTask;
|
||
|
||
let sp = [TASK_TYPE.LOGIN_SUM, TASK_TYPE.LOGIN_SERIES];
|
||
if(type == TASK_FUN_TYPE.DAILY && funcs.indexOf(FUNCS_ID.DAILY_TASK) == -1 && sp.indexOf(taskType) == -1) { // 功能未开启
|
||
return false;
|
||
}
|
||
|
||
|
||
let isMatch = true; // 条件是否满足
|
||
let checkHistory = false; // 是否检查历史
|
||
switch(taskType) {
|
||
case TASK_TYPE.ROLE_TITLE:
|
||
isMatch = taskParam[0] == param.title;
|
||
checkHistory = true;
|
||
break;
|
||
case TASK_TYPE.HERO_STAR_UP:
|
||
isMatch = taskParam[1] == param.star;
|
||
break;
|
||
case TASK_TYPE.HERO_QUALITY:
|
||
case TASK_TYPE.EQUIP_QUALITY:
|
||
isMatch = taskParam[1] == param.quality;
|
||
break;
|
||
case TASK_TYPE.HERO_QUALITY_STAR_UP:
|
||
isMatch = taskParam[1] == param.quality && taskParam[2] == param.star;
|
||
break;
|
||
case TASK_TYPE.HERO_LV:
|
||
isMatch = taskParam[1] == param.lv;
|
||
break;
|
||
case TASK_TYPE.HERO_TRAIN:
|
||
isMatch = taskParam[1] == param.count;
|
||
break;
|
||
case TASK_TYPE.HERO_FAVOUR_LV:
|
||
isMatch = taskParam[1] == param.favourLv;
|
||
break;
|
||
case TASK_TYPE.HERO_CONNECT:
|
||
isMatch = taskParam[1] == param.connectLv;
|
||
break;
|
||
case TASK_TYPE.EQUIP_BY_HERO:
|
||
isMatch = false;
|
||
if(param.isPutOn && param.count == taskParam[1]) { // 装上之后达到 +1
|
||
isMatch = true;
|
||
} else if (!param.isPutOn && param.count < taskParam[1]) { // 脱下后不能达到 -1
|
||
isMatch = true;
|
||
}
|
||
break;
|
||
case TASK_TYPE.EQUIP_STRENGTHEN:
|
||
isMatch = param.oldLv < taskParam[1] && param.lv >= taskParam[1];
|
||
break;
|
||
case TASK_TYPE.EQUIP_JEWEL_STAGE:
|
||
isMatch = param.stage == taskParam[1];
|
||
break;
|
||
case TASK_TYPE.CHAT:
|
||
isMatch = taskParam[0] == 0 || param.chatType == taskParam[0];
|
||
break;
|
||
case TASK_TYPE.BATTLE_WITH_HERO:
|
||
isMatch = checkIdList(taskParam, 2, param.warId) && checkHero(taskParam, 0, param.heroes);
|
||
break;
|
||
case TASK_TYPE.BATTLE_MAIN:
|
||
case TASK_TYPE.BATTLE_DUNGEON_WAR:
|
||
isMatch = checkIdList(taskParam, 0, param.warId);
|
||
break;
|
||
case TASK_TYPE.BATTLE_EVENT:
|
||
isMatch = taskParam[0] == 0 || param.eventType == taskParam[0];
|
||
break;
|
||
case TASK_TYPE.BATTLE_DAILY_STAR:
|
||
isMatch = (taskParam[0] == 0 || param.star == taskParam[0]) && checkIdList(taskParam, 2, param.warId);
|
||
break;
|
||
case TASK_TYPE.BATTLE_DAILY:
|
||
isMatch = taskParam[0] == 0 || param.dailyType == taskParam[0];
|
||
break;
|
||
case TASK_TYPE.BATTLE_EXPEDITION_BOX:
|
||
isMatch = taskParam[1] == 0 || param.point == taskParam[1];
|
||
break;
|
||
case TASK_TYPE.COM_BATTLE_BLUEPRT:
|
||
case TASK_TYPE.COM_BATTLE_QUALITY:
|
||
isMatch = taskParam[0] == 0 || param.quality == taskParam[0];
|
||
break;
|
||
case TASK_TYPE.COM_BATTLE_DROP:
|
||
isMatch = checkIdList(taskParam, 1, param.gid);
|
||
break;
|
||
case TASK_TYPE.PVP_HERO_SCORE:
|
||
for(let { score } of param.heroScores) {
|
||
if(score >= taskParam[0]) {
|
||
count++;
|
||
}
|
||
}
|
||
if(count <= 0) isMatch = false;
|
||
break;
|
||
case TASK_TYPE.PVP_RANK:
|
||
isMatch = taskParam[0] <= param.rankLv;
|
||
checkHistory = true;
|
||
break;
|
||
case TASK_TYPE.GUILD_JOB:
|
||
isMatch = taskParam[0] <= param.job && param.job != GUILD_JOB.DAJIANGJUN;
|
||
checkHistory = true;
|
||
break;
|
||
case TASK_TYPE.GUILD_REFINE:
|
||
isMatch = taskParam[0] == 0 || param.quality == taskParam[0];
|
||
break;
|
||
}
|
||
console.log('****isMatch', isMatch, checkHistory, type, taskType, group, count)
|
||
|
||
if(isMatch) {
|
||
if(isInc) {
|
||
let rec = await UserTaskRecModel.incTaskRec(roleId, type, taskType, group, count);
|
||
return rec;
|
||
} else {
|
||
if(checkHistory) {
|
||
let rec = await UserTaskRecModel.checkHistoryAndSetTaskRec(roleId, type, taskType, group, count);
|
||
return rec;
|
||
} else {
|
||
let rec = await UserTaskRecModel.setTaskRec(roleId, type, taskType, group, count);
|
||
return rec;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 检查id是否在某列表中
|
||
* @param taskParam 条件number[] 填法 如： count&id&... 有多少id就count填几
|
||
* @param index count在第几位，0开始
|
||
* @param id 关卡id
|
||
*/
|
||
function checkIdList(taskParam: number[], index: number, id: number) {
|
||
let count = taskParam[index];
|
||
if(!count) return false;
|
||
let idList = taskParam.slice(index + 1, index + 1 + count);
|
||
return idList.indexOf(id) != -1;
|
||
}
|
||
|
||
function checkHero(taskParam: number[], index: number, heroes: number[]) {
|
||
let hid = taskParam[index];
|
||
return heroes.indexOf(hid) != -1;
|
||
}
|
||
|
||
function checkRecResult(rec: UserTaskRecType, id: number, condition: number) {
|
||
if(!rec) return false;
|
||
if(rec.received && rec.received.includes(id)) return false; // 已领取，不再推送
|
||
|
||
if(rec.count >= condition) {
|
||
return rec
|
||
} else {
|
||
return false
|
||
}
|
||
} |