镇念塔：获取任务

2021-08-16 20:12:24 +08:00
parent 10265c6723
commit e1f4d7b52a
6 changed files with 184 additions and 98 deletions
--- a/game-server/app/servers/battle/handler/towerBattleHandler.ts
+++ b/game-server/app/servers/battle/handler/towerBattleHandler.ts
@@ -1,13 +1,13 @@
 import { STATUS } from './../../../consts/statusCode';
 import { HANG_UP_CONSTS, GOLD_COST_RATIO, TOWER_TASK_CONST, REDIS_KEY } from './../../../consts';
-import { TowerTaskRecModel } from './../../../db/TowerTaskRec';
+import { TowerTaskRecModel, TowerTaskRecType } from './../../../db/TowerTaskRec';
 import { HangUpSpdUpRecModel } from './../../../db/HangUpSpdUpRec';
 import { HangUpRecordModel } from './../../../db/HangUpRecord';
 import { RoleModel } from './../../../db/Role';
 import { TowerRecordModel } from './../../../db/TowerRecord';
 import { Application, BackendSession } from 'pinus';
 import { resResult, shouldRefresh, calculateNum, genCode } from '../../../pubUtils/util';
-import { calcuHangUpReward, checkTaskConditions, checkHangUpSpdUpCnt, createCurTasks, treatTask, getRemainTime, getDoingOrWaitingTasks, getTowerStatus, getHungupRewards, getTasks } from '../../../services/battleService';
+import { calcuHangUpReward, checkTaskConditions, checkHangUpSpdUpCnt, refreshTasks, treatTask, getRemainTime, getDoingOrWaitingTasks, getTowerStatus, getHungupRewards, getTasks, checkTaskRewards } from '../../../services/battleService';
 import { addItems, handleCost } from '../../../services/rewardService';
 import { checkBattleHeroes } from '../../../services/normalBattleService';
 import { getGoldObject } from '../../../pubUtils/itemUtils';
@@ -152,13 +152,12 @@ export class TowerBattleHandler {
        }
        
        // 只刷掉当前面板上没有做派遣的任务
-        const batchCode = genCode(8);
+        let batchCode = genCode(8);
        let curTasks = await TowerTaskRecModel.getCurTasks(roleId); // 当前显示中的任务
-        let {waitingTaskCode, doingTaskCode, doingIds} = getDoingOrWaitingTasks(curTasks, curTime);
-        await TowerTaskRecModel.hideTask(roleId, waitingTaskCode); // 隐藏没有在做的任务
-        await TowerTaskRecModel.updateBatchCode(roleId, doingTaskCode, batchCode); // 更新留下来的旧任务的batchCode
-        await createCurTasks(towerLv, batchCode, roleId, roleName, 0, waitingTaskCode.length, doingIds);
-        curTasks = await TowerTaskRecModel.getCurTasks(roleId);
+        for(let task of curTasks) {
+            if(task) batchCode = task.batchCode;
+        }
+        curTasks = await refreshTasks(towerLv, batchCode, roleId, roleName, curTasks);
        await RoleModel.increaseTowerRefCnt(roleId, 1);
        
        let refRemainTime = getRemainTime(curTime);
@@ -222,39 +221,30 @@ export class TowerBattleHandler {
        let roleName = session.get('roleName');
        let sid = session.get('sid');

-        let allFlag = !msg.taskCode;
+        const { batchCode, taskCode } = msg;
+        let allFlag = !taskCode;

        const curTime = new Date();
-        let curTasks = await TowerTaskRecModel.getCurTasks(roleId);
-        if (!curTasks || curTasks.length == 0) {
+        let tasks: TowerTaskRecType[] = [];
+        if(allFlag) {
+            tasks = await TowerTaskRecModel.getCurTasks(roleId);
+        } else {
+            let task = await TowerTaskRecModel.getTaskByCode(roleId, taskCode);
+            if(task) tasks.push(task);
+        }
+        if (!tasks || tasks.length == 0) {
            return resResult(STATUS.TOWER_TASK_NOT_FOUND);
        }
-        const compTasks: string[] = [];
-        let rewards: ItemInter[] = [];
-        for (let task of curTasks) {
-            if (task.batchCode !== msg.batchCode) {
-                return resResult(STATUS.TOWER_TASK_BATCH_NOT_FOUND);
-            }
-            if ((allFlag || task.taskCode === msg.taskCode) && task.status === 1) {
-                let {completeTime, reward, termsForAdd, additionalReward} = gameData.towerTask.get(task.taskId);
-                if (task.sendTime && task.sendTime.getTime() + completeTime * 1000 < curTime.getTime()) {
-                    compTasks.push(task.taskCode);
-                    rewards = rewards.concat(reward);
-                    if(termsForAdd) {
-                        const result = await checkTaskConditions(roleId, task.heroes, termsForAdd);
-                        if(result) {
-                            rewards = rewards.concat(additionalReward)
-                        }
-                    }
-                }
-            }
+        const checkResult = await checkTaskRewards(roleId, batchCode, tasks);
+        if (!checkResult) {
+            return resResult(STATUS.TOWER_TASK_BATCH_NOT_FOUND);
        }
+        const { compTasks, rewards } = checkResult;
        let goods = await addItems(roleId, roleName, sid, rewards);
        await TowerTaskRecModel.finishTask(msg.batchCode, compTasks);
-        await TowerTaskRecModel.showTask(roleId, msg.batchCode, compTasks.length);
        let refRemainTime = getRemainTime(curTime);

-        curTasks = await TowerTaskRecModel.getCurTasks(roleId); // 当前显示中的任务
+        let curTasks = await TowerTaskRecModel.getCurTasks(roleId); // 当前显示中的任务
        let costGold = TOWER_TASK_CONST.COST_GOLD;
        return resResult(STATUS.SUCCESS, { curTasks: treatTask(curTasks, curTime), goods, refRemainTime, nextCostGold: costGold });
    }
--- a/game-server/app/services/battleService.ts
+++ b/game-server/app/services/battleService.ts
@@ -1,14 +1,14 @@
 import { HeroModel } from './../db/Hero';
 import { HangUpRecordModel } from './../db/HangUpRecord';
 import { pinus } from 'pinus';
-import { HANG_UP_CONSTS, TOWER_TASK_CONST, REDIS_KEY, TASK_TYPE, TIME_OUTPUT_TYPE, GOLD_COST_RATIO } from './../consts';
+import { HANG_UP_CONSTS, TOWER_TASK_CONST, REDIS_KEY, TASK_TYPE, TIME_OUTPUT_TYPE, GOLD_COST_RATIO, TOWER_TASK_STATUS, MAIL_TYPE } from './../consts';
 import { BattleRecordModel } from './../db/BattleRecord';
 import { TowerRecordModel } from './../db/TowerRecord';
 import { RoleModel, RoleType } from './../db/Role';
 import { shouldRefresh, resResult, cal, getRandEelmWithWeight, calculateNum, genCode } from '../pubUtils/util';
 import { STATUS } from '../consts/statusCode';
 import { HangUpSpdUpRecModel } from '../db/HangUpSpdUpRec';
-import { TowerTaskRecModel } from '../db/TowerTaskRec';
+import { TowerTaskRecModel, TowerTaskRecType } from '../db/TowerTaskRec';
 import { cloneDeep } from 'lodash';
 import { Rank } from './rankService';
 import { checkActivityTask, checkTask } from './taskService';
@@ -16,6 +16,8 @@ import { getRandExpedition, gameData } from '../pubUtils/data';
 import { ItemInter, RewardInter } from '../pubUtils/interface';
 import { getTimeFunM } from '../pubUtils/timeUtil';
 import { ComRoleStatusHero } from '../db/ComBattleTeam';
+import { sendMailByContent } from './mailService';
+import { DicTowerTask } from '../pubUtils/dictionary/DicTowerTask';

 /**
 * 获取当前镇念塔状态
@@ -90,11 +92,15 @@ export async function getTasks(role: RoleType) {

    if(needRefresh) {
        const batchCode = genCode(8);
-        let {waitingTaskCode, doingTaskCode, doingIds} = getDoingOrWaitingTasks(curTasks, curTime);
-        await TowerTaskRecModel.hideTask(roleId, waitingTaskCode); // 隐藏没有在做的任务
-        await TowerTaskRecModel.updateBatchCode(roleId, doingTaskCode, batchCode); // 更新留下来的旧任务的batchCode
-        await createCurTasks(towerLv, batchCode, roleId, roleName, doingTaskCode.length, TOWER_TASK_CONST.RAND_CNT-doingTaskCode.length, doingIds); // 新建任务
-        curTasks = await TowerTaskRecModel.getCurTasks(roleId);
+        let preTasks = await TowerTaskRecModel.getPreTasks(roleId);
+        if(preTasks && preTasks.length) {
+            let checkResult = await checkTaskRewards(roleId, preTasks[0].batchCode, preTasks );
+            if(!checkResult) return false;
+            await sendMailByContent(MAIL_TYPE.TOWER_TASK_REWARD, roleId, { goods: checkResult.rewards });
+            await TowerTaskRecModel.finishTask(preTasks[0].batchCode, preTasks.map(cur => cur.taskCode));
+        }
+        
+        curTasks = await refreshTasks(towerLv, batchCode, roleId, roleName, []); // 新建任务

        // 重置派遣次数
        const role = await RoleModel.resetTowerCnt(roleId, curTime); 
@@ -107,6 +113,29 @@ export async function getTasks(role: RoleType) {
    return {curTasks: treatTask(curTasks, curTime), refRemainTime, nextCostGold}
 }

+export async function checkTaskRewards(roleId: string, batchCode: string, tasks: TowerTaskRecType[]) {
+    const curTime = new Date();
+    let compTasks: string[] = [];
+    let rewards: RewardInter[] = [];
+    for (let task of tasks) {
+        if(task.batchCode != batchCode) return false;
+        if ( task.status === TOWER_TASK_STATUS.DOINING) {
+            let {completeTime, reward, termsForAdd, additionalReward} = gameData.towerTask.get(task.taskId);
+            if (task.sendTime && task.sendTime.getTime() + completeTime * 1000 < curTime.getTime()) {
+                compTasks.push(task.taskCode);
+                rewards.push(...reward);
+                if(termsForAdd) {
+                    const result = await checkTaskConditions(roleId, task.heroes, termsForAdd);
+                    if(result) {
+                        rewards.push(...additionalReward);
+                    }
+                }
+            }
+        }
+    }
+    return { compTasks, rewards };
+}
+
 export async function checkTowerWar(roleId: string, battleId: number, heroes: Array<number>) {
    let { towerLv } = await RoleModel.findByRoleId(roleId);
    const towerInfo = gameData.tower.get(towerLv);
@@ -348,45 +377,79 @@ export async function checkTaskConditions(roleId: string, heroes: number[], cond
    return res;
 }

-/**
- * 创建新的派遣任务
- * @param towerLv 玩家层数
- * @param roleId 玩家id
- * @param roleName 玩家名
- * @param hideNum 隐藏的任务数量
- */
-export async function createCurTasks(towerLv: number, batchCode: string, roleId: string, roleName: string, hideNum: number, showNum: number, rids: Array<number>) {
-    let randomList = [];
-    let dicTask = gameData.towerTask;
-    for (let [_id, task] of dicTask) {
-        let { suitFloor: { min, max } } = task;
-        let flag = max ? (towerLv >= min && towerLv <= max) : (towerLv >= min);
-        if (flag) {
-            randomList.push(task);
+export async function refreshTasks(towerLv: number, batchCode: string, roleId: string, roleName: string, oldTasks:TowerTaskRecType[]) {
+    let ridTaskIds: number[] = [];
+    let positions = new Map<number, TowerTaskRecType> (); // 需要创建或更新
+    for(let i = 1; i <= TOWER_TASK_CONST.RAND_CNT; i++) { // TODO 改为系统参数表
+        positions.set(i, null);
+    }
+    for(let task of oldTasks) {
+        if( task.status == TOWER_TASK_STATUS.WAITING ) {
+            positions.set(task.position, task);
+        } else {
+            positions.delete(task.position);
+            ridTaskIds.push(task.taskId);
        }
    }
-    let returnTasks = new Array();
-    const arr = [{ refreshStatus: 0, num: hideNum }, { refreshStatus: 1, num: showNum }];
-    for (let { refreshStatus, num } of arr) {
-        let taskIds = [];
-        for (let i = 0; i < num; i++) {
-            let list = randomList.filter(cur => !rids.includes(cur.taskId));
-            let { dic: tmp } = getRandEelmWithWeight(list);
-            if (tmp) {
-                taskIds.push(tmp.taskId);
-                rids.push(tmp.taskId)
+
+    let tasks: TowerTaskRecType[] = [];
+    for(let [ position, task ] of positions) {
+        let taskId = randomTaskId(towerLv, task?task.taskId: 0, ridTaskIds);
+        if(task) { // 更新
+            await TowerTaskRecModel.updateTask(roleId, batchCode, position, taskId);
+        } else {
+            await TowerTaskRecModel.createTask(roleId, roleName, batchCode, taskId, position);
+        }
+        ridTaskIds.push(taskId);
+    }
+    return tasks
+}
+
+function randomTaskId(towerLv: number, oldTaskId: number, rids: number[]) {
+    let randomList: DicTowerTask[] = [];
+    let dicTask = gameData.towerTask;
+    let oldQuality = dicTask.has(oldTaskId)? dicTask.get(oldTaskId).quality: 0;
+
+    for (let [_id, task] of dicTask) {
+        if(task.quality >= oldQuality + 1) {
+            let { suitFloor: { min, max } } = task;
+            let flag = max ? (towerLv >= min && towerLv <= max) : (towerLv >= min);
+            if (flag) {
+                randomList.push(task);
            }
        }
-        const curTasks = await TowerTaskRecModel.createTasks(roleId, roleName, batchCode, taskIds, refreshStatus);
-
-        if (refreshStatus == 1) {
-            returnTasks = curTasks;
-        }
    }
-
-    return returnTasks;
+    let list = randomList.filter(cur => !rids.includes(cur.taskId));
+    let { dic } = getRandEelmWithWeight(list);
+    
+    return dic.taskId;
 }

+// /**
+//  * 创建新的派遣任务
+//  * @param towerLv 玩家层数
+//  * @param roleId 玩家id
+//  * @param roleName 玩家名
+//  * @param hideNum 隐藏的任务数量
+//  */
+// export async function createCurTasks(towerLv: number, batchCode: string, roleId: string, roleName: string, hideNum: number, showNum: number, rids: Array<number>) {
+
+//     let returnTasks = new Array();
+//     const arr = [{ refreshStatus: 0, num: hideNum }, { refreshStatus: 1, num: showNum }];
+//     for (let { refreshStatus, num } of arr) {
+//         let taskIds = [];
+//         for (let i = 0; i < num; i++) {
+//         }
+//         const curTasks = await TowerTaskRecModel.createTasks(roleId, roleName, batchCode, taskIds, refreshStatus);
+
+//         if (refreshStatus == 1) {
+//             returnTasks = curTasks;
+//         }
+//     }
+
+//     return returnTasks;
+// }
+
 export function getRemainTime(curTime: Date) {
    let nextTime = <number>getTimeFunM(curTime).getAfterDayWithHour(1);
    return Math.floor((nextTime - curTime.getTime()) / 1000);