任务：完成主要接口

2021-04-20 17:52:50 +08:00
parent b29b8634ad
commit ced80d9b94
16 changed files with 515 additions and 41 deletions
@@ -10,7 +10,7 @@ import { getTaskById, getTowerDataByLv } from '../../../pubUtils/gamedata';
 import { decodeArrayStr, resResult, shouldRefresh, calculateNum, getRefTime, genCode } from '../../../pubUtils/util';
 import { calcuHangUpReward, checkTaskConditions, checkHangUpSpdUpCnt, createCurTasks, treatTask, getRemainTime, getTasksReward, getTaskStatus, getDoingOrWaitingTasks } from '../../../services/battleService';
 import { handleFixedReward, addItems, handleCost } from '../../../services/rewardService';
-import { checkBattleHeroesByHid } from '../../../services/normalBattleService';
+import { checkBattleHeroes } from '../../../services/normalBattleService';
 import { getGoldObject } from '../../../pubUtils/itemUtils';
 import { Rank } from '../../../services/rankService';

@@ -241,8 +241,8 @@ export class TowerBattleHandler {
            if (task.heroes.length !== taskInfo.actorNeeded) { // 武将数，从策划表中读取
                return resResult(STATUS.TOWER_TASK_MAX_HERO);
            }
-            let hasHero = await checkBattleHeroesByHid(roleId, task.heroes);
-            if(!hasHero) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
+            let { isOK } = await checkBattleHeroes(roleId, task.heroes);
+            if(!isOK) return resResult(STATUS.BATTLE_HERO_NOT_FOUND);
            if (tasksCode.indexOf(task.taskCode) === -1) {
                return resResult(STATUS.TOWER_TASK_CODE_NOT_FOUND);
            }
@@ -22,7 +22,7 @@ import { getMails } from '../../../services/mailService';
 import { addRoleToGuildChannel, addRoleToSysChannel, addRoleToWorldChannel, leaveGuildChannel, leaveSysChannel, leaveWorldChannel, recentGuildMsgs, recentPrivateChatInfos, recentSysMsgs, recentWorldMsgs } from '../../../services/chatService';
 import { reportOneOnline } from '../../../services/timeTaskService';
 import { Rank } from '../../../services/rankService';
-import { checkTaskWithRole } from '../../../services/taskService';
+import { checkTaskWithRole, getCurTask } from '../../../services/taskService';
 export default function (app: Application) {
    return new EntryHandler(app);
 }
@@ -152,6 +152,11 @@ export class EntryHandler {
                }
            }
        }
+        // 任务
+        let { mainTask, dailyTask, achievement } = await getCurTask(role.roleId);
+        role['mainTask'] = mainTask;
+        role['dailyTask'] = dailyTask;
+        role['achievement'] = achievement;

        return resResult(STATUS.SUCCESS, { role });
    }
@@ -0,0 +1,182 @@
+import { Application, BackendSession } from "pinus";
+import { resResult, parseGoodStr } from "../../../pubUtils/util";
+import { STATUS, TASK_FUN_TYPE } from "../../../consts";
+import { gameData } from "../../../pubUtils/data";
+import { UserTaskRecModel } from "../../../db/UserTaskRec";
+import { addItems } from "../../../services/rewardService";
+import { UserTaskModel } from "../../../db/UserTask";
+import { getCurWeekDate } from "../../../pubUtils/timeUtil";
+import { DicDailyTask, DicAchievement } from "../../../pubUtils/dictionary/DicTask";
+import { getMainTask } from "../../../services/taskService";
+import { TASK } from "../../../pubUtils/dicParam";
+import { RewardInter } from "../../../pubUtils/interface";
+
+export default function(app: Application) {
+    return new ShopHandler(app);
+}
+
+export class ShopHandler {
+    constructor(private app: Application) {
+    }
+
+    // 领取主线任务、每日任务、成就单条任务
+    async receiveTask(msg: { type: number, id: number }, session: BackendSession) {
+        const roleId: string = session.get('roleId');
+        const roleName: string = session.get('roleName');
+        const sid: string = session.get('sid');
+        const { type, id } = msg;
+
+        let dicTask = gameData.tasks.get(type).get(id);
+        let { group, taskType, taskReward, condition } = dicTask;
+        // 检查
+        let rec = await UserTaskRecModel.findByRoleAndGroup(roleId, type, taskType, group);
+        if(!rec) return resResult(STATUS.TASK_NOT_REACH_CONDITION);
+        if(rec.count < condition) return resResult(STATUS.TASK_NOT_REACH_CONDITION);
+        if(rec.received.includes(id)) return resResult(STATUS.TASK_HAS_RECEIVED);
+
+        // 领取记录
+        rec = await UserTaskRecModel.receiveTask(roleId, type, taskType, group, id);
+
+        // 每日、成就增加积分
+        let point = 0, weeklyPoint = 0;
+        if(type == TASK_FUN_TYPE.DAILY) { // 增加积分
+            let userTask = await UserTaskModel.findByRole(roleId);
+            let dic = <DicDailyTask>dicTask;
+            let curWeek = getCurWeekDate(1, 5);
+            if(curWeek > userTask.dailyTaskRefWeekly) {
+                userTask = await UserTaskModel.resetDailyScore(roleId, dic.point, curWeek);
+            } else {
+                userTask = await UserTaskModel.incInfo(roleId, { dailyTaskPoint: dic.point, dailyTaskPointWeekly: dic.point });
+            }
+            point = userTask.dailyTaskPoint;
+            weeklyPoint = userTask.dailyTaskPointWeekly;
+        } else if (type == TASK_FUN_TYPE.ACHIEVEMENT) {
+            let dic = <DicAchievement>dicTask;
+            let userTask = await UserTaskModel.incInfo(roleId, { achievementPoint: dic.point });
+            point = userTask.achievementPoint;
+        }
+
+        let goods = await addItems(roleId, roleName, sid, taskReward);
+
+        return resResult(STATUS.SUCCESS, {
+            type, id, count: rec.count, received: rec.received.includes(id),
+            point, weeklyPoint,
+            goods
+        });
+    }
+
+    // 领取主线阶段奖励
+    async receiveMainStage(msg: { stage: number }, session: BackendSession) {
+
+        const roleId: string = session.get('roleId');
+        const roleName: string = session.get('roleName');
+        const sid: string = session.get('sid');
+        const { stage } = msg;
+
+        let dicMainStage = gameData.mainTaskStage.get(stage);
+        if(!dicMainStage) return resResult(STATUS.DIC_DATA_NOT_FOUND);
+
+        // 检查
+        let userTask = await UserTaskModel.findByRole(roleId);
+        if(userTask.mainTaskStage != stage) {
+            return resResult(STATUS.WRONG_PARMS);
+        }
+        let recs = await UserTaskRecModel.getReceiveRec(roleId, TASK_FUN_TYPE.MAIN);
+        for(let id of dicMainStage.mainTaskId) {
+            let curRecs = recs.find(cur => cur.received.includes(id));
+            if(!curRecs) return resResult(STATUS.TASK_NOT_ALL_RECEIVED);
+        }
+        // 更新数据
+        userTask = await UserTaskModel.incInfo(roleId, { mainTaskStage: 1 });
+
+        let goods = await addItems(roleId, roleName, sid, dicMainStage.reward);
+        let mainTask = await getMainTask(roleId, userTask);
+
+        return resResult(STATUS.SUCCESS, {
+            type: TASK_FUN_TYPE.MAIN,
+            ...mainTask,
+            goods
+        });
+    }
+
+    // 领取每日活跃奖励
+    async receiveActiveReward(msg: { }, session: BackendSession) {
+
+        const roleId: string = session.get('roleId');
+        const roleName: string = session.get('roleName');
+        const sid: string = session.get('sid');
+
+        // 检查
+        let userTask = await UserTaskModel.findByRole(roleId);
+        let { dailyTaskPoint } = userTask;
+        if(dailyTaskPoint < TASK.DAILYTASK_POINT) {
+            return resResult(STATUS.TASK_ACTIVE_NOT_ENOUGH);
+        }
+        // 更新数据
+        userTask = await UserTaskModel.decreaseDailyPoint(roleId, TASK.DAILYTASK_POINT);
+        if(!userTask) return resResult(STATUS.TASK_ACTIVE_NOT_ENOUGH);
+
+        let reward = parseGoodStr(TASK.DAILYTASK_POINT_REWARD);
+        let goods = await addItems(roleId, roleName, sid, reward);
+
+        return resResult(STATUS.SUCCESS, {
+            type: TASK_FUN_TYPE.DAILY,
+            point: userTask.dailyTaskPoint,
+            goods
+        });
+    }
+
+    // 领取每日周宝箱
+    async receiveBox(msg: { type: number, id: number }, session: BackendSession) {
+        const roleId: string = session.get('roleId');
+        const roleName: string = session.get('roleName');
+        const sid: string = session.get('sid');
+        const { type, id } = msg;
+
+        let userTask = await UserTaskModel.findByRole(roleId);
+        let dicTaskBox = gameData.taskBox.get(type)?.get(id);
+        if(!dicTaskBox) return resResult(STATUS.DIC_DATA_NOT_FOUND);
+
+        let point = 0, weeklyPoint = 0, box: number[] = [];
+        // 每日、成就增加积分
+        if(type == TASK_FUN_TYPE.DAILY) { // 增加积分
+            let curWeek = getCurWeekDate(1, 5);
+            let shouldRefresh = false;
+            let { dailyTaskPointWeekly, dailyTaskBox, dailyTaskRefWeekly } = userTask;
+
+            if(curWeek > dailyTaskRefWeekly) {
+                shouldRefresh = true;
+                dailyTaskPointWeekly = 0;
+                dailyTaskBox = [];
+            }
+            if(dailyTaskPointWeekly > dicTaskBox.point) return resResult(STATUS.TASK_ACTIVE_NOT_ENOUGH);
+            if(dailyTaskBox.includes(id)) return resResult(STATUS.TASK_BOX_HAS_RECEIVED);
+
+            userTask = await UserTaskModel.pushDailyBox(roleId, id, curWeek, shouldRefresh);
+
+            point = userTask.dailyTaskPoint;
+            box = userTask.dailyTaskBox;
+            weeklyPoint = userTask.dailyTaskPointWeekly;
+
+        } else if (type == TASK_FUN_TYPE.ACHIEVEMENT) {
+            let { achievementPoint, achievementBox } = userTask;
+            if(achievementPoint > dicTaskBox.point) return resResult(STATUS.TASK_ACTIVE_NOT_ENOUGH);
+            if(achievementBox.includes(id)) return resResult(STATUS.TASK_BOX_HAS_RECEIVED);
+
+            userTask = await UserTaskModel.pushAchievementBox(roleId, id);
+
+            point = userTask.achievementPoint;
+            box = userTask.achievementBox;
+        } else {
+            return resResult(STATUS.WRONG_PARMS);
+        }
+
+        let goods = await addItems(roleId, roleName, sid, dicTaskBox.reward);
+
+        return resResult(STATUS.SUCCESS, {
+            type,
+            point, weeklyPoint, box,
+            goods
+        });
+    }
+}
@@ -65,7 +65,9 @@ export async function checkBattleHeroes(roleId: string, seqIds: Array<number>) {
    if(findHeroes.length != seqIds.length) flag = false;
    for(let seqId of seqIds) {
        let hero = findHeroes.find(cur => cur.seqId == seqId);
-        if(!hero) flag = false;
+        if(!hero) {
+            flag = false; break;
+        }
        heroes.push(hero.hid);
    }
    return { isOK: flag, heroes };
@@ -2,13 +2,17 @@ import * as taskUtil from '../pubUtils/taskUtil';
 import { RoleType } from '../db/Role';
 import { pinus } from 'pinus';
 import { resResult } from '../pubUtils/util';
-import { STATUS, TASK_TYPE } from '../consts';
-import { TaskParam } from '../domain/roleField/task';
+import { STATUS, TASK_TYPE, TASK_FUN_TYPE } from '../consts';
+import { TaskParam, TaskListReturn } from '../domain/roleField/task';
 import { HeroType } from '../db/Hero';
 import { EquipType } from '../db/Equip';
 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 { gameData } from '../pubUtils/data';
+import { getCurWeekDate } from '../pubUtils/timeUtil';

 export async function checkTaskWithRoles(roleId: string, sid: string, funcs: number[], taskType: number, roles: RoleType[]) {
    for(let role of roles) {
@@ -53,15 +57,17 @@ export async function checkTask(roleId: string, sid: string, funcs: number[], ta
    pushTaskUpdate(roleId, sid, funcs, pushMessage);
 }

-export async function pushTaskUpdate(roleId: string, sid: string, funcs: number[], pushMessage: {type: number, id: number, count: number, received: boolean}[]) {
-    if(!sid || !funcs) {
-        let onlineUser = await getRoleOnlineInfo(roleId);
-        sid = onlineUser.sid;
-        funcs = onlineUser.funcs||[];
-    }
-    if(!!sid) {
-        let uids = [{uid: roleId, sid}];
-        pinus.app.get('channelService').pushMessageByUids('onTaskUpdate', resResult(STATUS.SUCCESS, pushMessage), uids);
+export async function pushTaskUpdate(roleId: string, sid: string, funcs: number[], pushMessage: TaskListReturn[]) {
+    if(pushMessage.length > 0) {
+        if(!sid || !funcs) {
+            let onlineUser = await getRoleOnlineInfo(roleId);
+            sid = onlineUser.sid;
+            funcs = onlineUser.funcs||[];
+        }
+        if(!!sid) {
+            let uids = [{uid: roleId, sid}];
+            pinus.app.get('channelService').pushMessageByUids('onTaskUpdate', resResult(STATUS.SUCCESS, pushMessage), uids);
+        }
    }
 }

@@ -104,4 +110,72 @@ export async function checkTaskInPvpEnd(roleId: string, sid: string, funcs: numb
    }

    await checkTask(roleId, sid, funcs, TASK_TYPE.PVP, 0, false, { heroScores });
+}
+
+
+// 获取task状态
+export async function getCurTask(roleId: string) {
+    let userTask = await UserTaskModel.findByRole(roleId);
+    let mainTask = await getMainTask(roleId, userTask);
+    let dailyTask = await getDailyTask(roleId, userTask);
+    let achievement = await getAchievement(roleId, userTask);
+    return { mainTask, dailyTask, achievement };
+}
+
+export async function getMainTask(roleId: string, userTask: UserTaskType) {
+    let type = TASK_FUN_TYPE.MAIN;
+    let { mainTaskStage: stage } = userTask;
+    let recMap = await UserTaskRecModel.findByRoleAndType(roleId, type); // group=>userTaskRec
+
+    let taskList: TaskListReturn[] = [];
+    for(let [id, dic] of gameData.mainTask) {
+        if(dic.taskStage == stage) {
+            let dbRec = recMap.get(dic.taskType)?.get(dic.group);
+            if(dbRec) {
+                taskList.push({ type, id, count: dbRec.count, received: dbRec.received.includes(id) });
+            } else {
+                taskList.push({ type, id, count: 0, received: false });
+            }
+        }
+    }
+    return { stage, taskList }
+}
+
+export async function getDailyTask(roleId: string, userTask: UserTaskType) {
+    let type = TASK_FUN_TYPE.DAILY;
+    let { dailyTaskPoint: point, dailyTaskRefWeekly, dailyTaskPointWeekly: weeklyPoint, dailyTaskBox: box } = userTask;
+    let curWeekStart = getCurWeekDate(1, 5);
+    if(dailyTaskRefWeekly < curWeekStart) { // 刷新
+        weeklyPoint = 0;
+        box = [];
+    }
+    let recMap = await UserTaskRecModel.findByRoleAndType(roleId, type); // group=>userTaskRec
+
+    let taskList: TaskListReturn[] = [];
+    for(let [id, dic] of gameData.dailyTask) {
+        let dbRec = recMap.get(dic.taskType)?.get(dic.group);
+        if(dbRec) {
+            taskList.push({ type, id, count: dbRec.count, received: dbRec.received.includes(id) });
+        } else {
+            taskList.push({ type, id, count: 0, received: false });
+        }
+    }
+    return { point, weeklyPoint, taskList, box }
+}
+
+export async function getAchievement(roleId: string, userTask: UserTaskType) {
+    let type = TASK_FUN_TYPE.ACHIEVEMENT;
+    let { achievementBox: box, achievementPoint: point } = userTask;
+    let recMap = await UserTaskRecModel.findByRoleAndType(roleId, type); // group=>userTaskRec
+
+    let taskList: TaskListReturn[] = [];
+    for(let [id, dic] of gameData.dailyTask) {
+        let dbRec = recMap.get(dic.taskType)?.get(dic.group);
+        if(dbRec) {
+            taskList.push({ type, id, count: dbRec.count, received: dbRec.received.includes(id) });
+        } else {
+            taskList.push({ type, id, count: 0, received: false });
+        }
+    }
+    return { point, taskList, box }
 }