镇念塔：获取任务

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);
+        for(let task of curTasks) {
-        await TowerTaskRecModel.hideTask(roleId, waitingTaskCode); // 隐藏没有在做的任务
+            if(task) batchCode = task.batchCode;
-        await TowerTaskRecModel.updateBatchCode(roleId, doingTaskCode, batchCode); // 更新留下来的旧任务的batchCode
+        }
-        await createCurTasks(towerLv, batchCode, roleId, roleName, 0, waitingTaskCode.length, doingIds);
+        curTasks = await refreshTasks(towerLv, batchCode, roleId, roleName, curTasks);
-        curTasks = await TowerTaskRecModel.getCurTasks(roleId);
         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);
+        let tasks: TowerTaskRecType[] = [];
-        if (!curTasks || curTasks.length == 0) {
+        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[] = [];
+        const checkResult = await checkTaskRewards(roleId, batchCode, tasks);
-        let rewards: ItemInter[] = [];
+        if (!checkResult) {
-        for (let task of curTasks) {
+            return resResult(STATUS.TOWER_TASK_BATCH_NOT_FOUND);
-            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 { 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 });
     }

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);
+        let preTasks = await TowerTaskRecModel.getPreTasks(roleId);
-        await TowerTaskRecModel.hideTask(roleId, waitingTaskCode); // 隐藏没有在做的任务
+        if(preTasks && preTasks.length) {
-        await TowerTaskRecModel.updateBatchCode(roleId, doingTaskCode, batchCode); // 更新留下来的旧任务的batchCode
+            let checkResult = await checkTaskRewards(roleId, preTasks[0].batchCode, preTasks );
-        await createCurTasks(towerLv, batchCode, roleId, roleName, doingTaskCode.length, TOWER_TASK_CONST.RAND_CNT-doingTaskCode.length, doingIds); // 新建任务
+            if(!checkResult) return false;
-        curTasks = await TowerTaskRecModel.getCurTasks(roleId);
+            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;
 }
 
-/**
+export async function refreshTasks(towerLv: number, batchCode: string, roleId: string, roleName: string, oldTasks:TowerTaskRecType[]) {
- * 创建新的派遣任务
+    let ridTaskIds: number[] = [];
- * @param towerLv 玩家层数
+    let positions = new Map<number, TowerTaskRecType> (); // 需要创建或更新
- * @param roleId 玩家id
+    for(let i = 1; i <= TOWER_TASK_CONST.RAND_CNT; i++) { // TODO 改为系统参数表
- * @param roleName 玩家名
+        positions.set(i, null);
- * @param hideNum 隐藏的任务数量
+    }
- */
+    for(let task of oldTasks) {
-export async function createCurTasks(towerLv: number, batchCode: string, roleId: string, roleName: string, hideNum: number, showNum: number, rids: Array<number>) {
+        if( task.status == TOWER_TASK_STATUS.WAITING ) {
-    let randomList = [];
+            positions.set(task.position, task);
-    let dicTask = gameData.towerTask;
+        } else {
-    for (let [_id, task] of dicTask) {
+            positions.delete(task.position);
-        let { suitFloor: { min, max } } = task;
+            ridTaskIds.push(task.taskId);
-        let flag = max ? (towerLv >= min && towerLv <= max) : (towerLv >= min);
-        if (flag) {
-            randomList.push(task);
         }
     }
-    let returnTasks = new Array();
+
-    const arr = [{ refreshStatus: 0, num: hideNum }, { refreshStatus: 1, num: showNum }];
+    let tasks: TowerTaskRecType[] = [];
-    for (let { refreshStatus, num } of arr) {
+    for(let [ position, task ] of positions) {
-        let taskIds = [];
+        let taskId = randomTaskId(towerLv, task?task.taskId: 0, ridTaskIds);
-        for (let i = 0; i < num; i++) {
+        if(task) { // 更新
-            let list = randomList.filter(cur => !rids.includes(cur.taskId));
+            await TowerTaskRecModel.updateTask(roleId, batchCode, position, taskId);
-            let { dic: tmp } = getRandEelmWithWeight(list);
+        } else {
-            if (tmp) {
+            await TowerTaskRecModel.createTask(roleId, roleName, batchCode, taskId, position);
-                taskIds.push(tmp.taskId);
+        }
-                rids.push(tmp.taskId)
+        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;
-        }
     }
-
+    let list = randomList.filter(cur => !rids.includes(cur.taskId));
-    return returnTasks;
+    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);

shared/consts/constModules/battleConst.ts

@@ -168,3 +168,11 @@ export const COM_BATTLE_ROBOT_ID_NAME = [
 export const ROBOT_NAME = [
   '徐埋农', '简普瞳', '邛瑛', '嵇晁伊', '颜校', '吉辉娇', '罗宾', 'A', 'B', 'C', 'D', 'E', 'F'
 ];
+
+// 镇念塔状态
+export enum TOWER_TASK_STATUS {
+    WAITING = 0,     // 待派遣
+    DOINING = 1,     // 已派遣，进行中
+    FINISH = 2,      // 派遣结束
+    RECEIVED = 3,    // 已领取
+}

shared/consts/constModules/mailConst.ts

@@ -37,6 +37,7 @@ export enum MAIL_TYPE {
     MONTHLY_REWARD = 16, // 月卡奖品
     AUTION_REWARD = 17,  // 拍卖行忘领取奖励
     EQUIP_OVER = 18,  // 拍卖行忘领取奖励
+    TOWER_TASK_REWARD = 19, // 镇念塔派遣过期奖励
 };
 
 export const SEND_NAME = '系统';

shared/db/TowerTaskRec.ts

@@ -1,17 +1,8 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
-
+import { TOWER_TASK_STATUS } from '../consts';
-function genCodeTmp(len) {
+import { genCode } from '../pubUtils/util';
-  const chars = '123456789ABCDEFGHJKLMNPQRSTWXYZabcdefghijklmnopqrstuvwxyz';
+import { getZeroPointD } from '../pubUtils/timeUtil';
-  const charArr = chars.split('');
-  let code = '';
-  for (let i = 0; i < len; i++) {
-    code += charArr[Math.floor(Math.random() * charArr.length)];
-  }
-  return code;
-}
-
-
 
 /**
   * 天梯派遣记录表
@@ -24,16 +15,16 @@ export default class TowerTaskRec extends BaseModel {
   @prop({ required: true })
   roleName: string; // 角色名
 
-  @prop({ required: true})
+  @prop({ required: true })
   batchCode: string; // 本批派遣任务唯一标识
-  @prop({ required: true, default: 0})
+  @prop({ required: true })
-  status: number; // 派遣任务当前状态，0-可派遣，1-已派遣，2-已完成，3-已领取
+  position: number; // 本批派遣任务当中的第几个任务
-  @prop({ required: true, default: 1})
+  @prop({ required: true, default: 0, enum: TOWER_TASK_STATUS })
-  refreshStatus: number; // 派遣任务是否显示 -1-刷掉 0-隐藏 1-显示
+  status: TOWER_TASK_STATUS; // 派遣任务当前状态，0-可派遣，1-已派遣，2-已完成，3-已领取
   @prop({ required: true, type: Number, default: [] })
   heroes: Array<number>; // 此批派遣使用的全部武将
 
-  @prop({ required: true})
+  @prop({ required: true })
   taskId: number; // 任务唯一 Id，来自任务表
   @prop({ required: true })
   taskCode: string; // 服务器生成的任务唯一编号
@@ -42,22 +33,50 @@ export default class TowerTaskRec extends BaseModel {
   @prop({ required: false })
   completeTime: Date; // 派遣结束时间
 
-  public static async getCurTasks(roleId: string, lean = true) {
+  public static async getCurTasks(roleId: string) {
-    const recs: TowerTaskRecType[] = await TowerTaskRecModel.find({roleId, refreshStatus: 1}).sort({createdAt: 1}).lean(lean);
+    let today = getZeroPointD();
+    const recs: TowerTaskRecType[] = await TowerTaskRecModel.find({ roleId, createdAt: { $gte: today } }).sort({ position: 1}).lean();
     return recs;
   }
 
-  public static async createTasks(roleId: string, roleName: string, batchCode: string, taskIds: Array<number>, refreshStatus: number) {
+  public static async getPreTasks(roleId: string) {
-    const tasksData = taskIds.map(id => {
+    let today = getZeroPointD();
+    const recs: TowerTaskRecType[] = await TowerTaskRecModel.find({ roleId, createdAt: { $lt: today }, status: TOWER_TASK_STATUS.DOINING }).sort({ position: 1}).lean();
+    return recs;
+  }
+
+  public static async getTaskByCode(roleId: string, taskCode: string) {
+    let today = getZeroPointD();
+    const recs: TowerTaskRecType = await TowerTaskRecModel.findOne({ roleId, taskCode, createdAt: { $gte: today } }).lean();
+    return recs;
+  }
+
+  public static async createTasks(roleId: string, roleName: string, batchCode: string, taskIds: Array<number>) {
+    const tasksData = taskIds.map((id, index) => {
       const taskModel = new TowerTaskRecModel();
-      const taskCode = genCodeTmp(6);
+      const taskCode = genCode(6);
-      const taskData = Object.assign(taskModel.toJSON(), {batchCode, taskId: id, taskCode, roleId, roleName, refreshStatus});
+      const taskData = Object.assign(taskModel.toJSON(), {batchCode, taskId: id, taskCode, roleId, roleName, position: index + 1 });
       return taskData;
     });
     const recs = await TowerTaskRecModel.insertMany(tasksData, {ordered: false});
     return recs;
   }
 
+  public static async createTask(roleId: string, roleName: string, batchCode: string, taskId: number, position: number) {
+    const taskModel = new TowerTaskRecModel();
+    const taskCode = genCode(6);
+    const taskData = Object.assign(taskModel.toJSON(), {batchCode, taskId, taskCode, roleId, roleName, position });
+    delete taskData._id;
+
+    const recs: TowerTaskRecType = await TowerTaskRecModel.findOneAndUpdate({ taskCode }, { $setOnInsert: taskData }, { new: true, upsert: true }).lean();
+    return recs;
+  }
+
+  public static async updateTask(roleId: string, batchCode: string, position: number, taskId: number) {
+    const recs: TowerTaskRecType = await TowerTaskRecModel.findOneAndUpdate({ roleId, batchCode, position, status: TOWER_TASK_STATUS.WAITING }, { $set: { taskId } }).lean();
+    return recs;
+  }
+
   public static async getTasksByCode(batchCode: string, lean = true) {
     const recs: TowerTaskRecType[] = await TowerTaskRecModel.find({batchCode}).lean(lean);
     return recs;
@@ -67,8 +86,8 @@ export default class TowerTaskRec extends BaseModel {
     let recs = new Array();
     for (let {taskCode, heroes, completeTime} of tasks) {
       const rec: TowerTaskRecType = await TowerTaskRecModel.findOneAndUpdate(
-        {batchCode, taskCode: taskCode, refreshStatus: 1},
+        { batchCode, taskCode: taskCode },
-        {heroes: heroes, status: 1, sendTime, completeTime: new Date(sendTime.getTime() + completeTime * 1000)},
+        {heroes: heroes, status: TOWER_TASK_STATUS.DOINING, sendTime, completeTime: new Date(sendTime.getTime() + completeTime * 1000)},
         {new: true}).lean(lean);
 
       recs.push(rec);
@@ -76,7 +95,7 @@ export default class TowerTaskRec extends BaseModel {
     return recs;
   }
 
-  public static async finishTask(batchCode: string, tasks: Array<string>, _lean = true) {
+  public static async finishTask(batchCode: string, tasks: Array<string>) {
     const recs:{ok: number, n:number, nModified:number} = await TowerTaskRecModel.updateMany({batchCode, taskCode: {$in:tasks}}, {status: 3, refreshStatus: -1});
     return recs;
   }

shared/resource/jsons/dic_email_content.json

@@ -93,5 +93,10 @@
         "id": 18,
         "content": "<color= #000000>亲爱的小将军，您的背包中装备数量已满，请及时清理背包哦。溢出装备已通过邮件发放，请查收</color>",
         "time": 24
+    },
+    {
+        "id": 19,
+        "content": "<color= #000000>镇念塔</color>",
+        "time": 24
     }
 ]