feature:

天梯派遣功能
fix:
天梯挂机等bug修复

game-server/app/servers/battle/handler/towerBattleHandler.ts

@@ -5,9 +5,9 @@ import { HangUpRecordModel } from './../../../db/HangUpRecord';
 import { RoleModel } from './../../../db/Role';
 import { TowerRecordModel } from './../../../db/TowerRecord';
 import { Application, BackendSession } from 'pinus';
-import { getTaskIdByQuality, getTowerDataByLv } from '../../../util/gamedata';
+import { getTaskById, getTaskIdByQuality, getTowerDataByLv } from '../../../util/gamedata';
 import { decodeArrayStr, decodeIdCntArrayStr, getRandEelm } from '../../../util/util';
-import { calcuHangUpReward } from '../../../services/battleService';
+import { calcuHangUpReward, checkTaskConditions } from '../../../services/battleService';
 import { handleFixedReward } from '../../../services/rewardService';
 
 export default function(app: Application) {
@@ -154,23 +154,110 @@ export class TowerBattleHandler {
         };
     }
 
-    async getTask(msg: {}, session: BackendSession) {
+    async getTasks(msg: {}, session: BackendSession) {
         let roleId = session.get('roleId');
         let roleName = session.get('roleName');
-        let curTask = await TowerTaskRecModel.getCurTask(roleId);
-        if (!curTask) {
+        let curTasks = await TowerTaskRecModel.getCurTasks(roleId);
+        if (!curTasks || curTasks.length == 0) {
             let taskIds = [];
-            TOWER_TASK_CONST.RAND_CNT.forEach(qualityId => {
-                const ids = getTaskIdByQuality(qualityId);
-                taskIds.concat(getRandEelm(ids, 1));
+            TOWER_TASK_CONST.RAND_CNT.forEach((cnt, idx) => {
+                const ids = getTaskIdByQuality(idx + 1);
+                const tmp = getRandEelm(ids, cnt);
+                taskIds = taskIds.concat(getRandEelm(ids, cnt));
             })
-            curTask = await TowerTaskRecModel.createTask(roleId, roleName, taskIds);
+            curTasks = await TowerTaskRecModel.createTasks(roleId, roleName, taskIds);
         }
         return {
             code: 200,
             data: {
                 msg: '成功',
-                curTask
+                curTasks
+            }
+        }
+    }
+
+    async sendTaskHero(msg: {batchCode: string, tasks: Array<{taskCode: string, heroes: Array<number>}>}, session: BackendSession) {
+        let roleId = session.get('roleId');
+        const curTasks = await TowerTaskRecModel.getCurTasks(roleId);
+        if (!curTasks || curTasks.length == 0) {
+            return { code: 201, data: {msg: '没有可用派遣任务'}};
+        }
+        let usedHeroes = [];
+        const tasksCode = [];
+        curTasks.forEach(task => {
+            usedHeroes = usedHeroes.concat(task.heroes);
+            tasksCode.push(task.taskCode);
+        });
+        for (let task of msg.tasks) {
+            if (task.heroes.length > TOWER_TASK_CONST.MAX_HEROES_NUM) {
+                return { code: 201, data: {msg: '一个任务最多派遣三个武将'}};
+            }
+            if (usedHeroes.length > 0) {
+                let used = false;
+                task.heroes.forEach(hid => {
+                    if (usedHeroes.indexOf(hid) !== -1) {
+                        used = true;
+                    }
+                })
+                if (used) {
+                    return { code: 201, data: {msg: '武将已经派遣到其他任务'}};
+                }
+            }
+            if (tasksCode.indexOf(task.taskCode) === -1) {
+                return { code: 201, data: {msg: '未找到此任务编号'}};
+            }
+        }
+        const curTime = new Date();
+        const recs = await TowerTaskRecModel.sendHeroes(roleId, msg.batchCode, msg.tasks, curTime);
+        if (!recs || recs.length === 0) {
+            return { code: 201, data: {msg: '任务更新失败，请检查任务编号'}};
+        }
+        return {
+            code: 200,
+            data: {
+                msg: '派遣成功',
+                tasks: recs
+            }
+        }
+    }
+
+    async settleTask(msg: {batchCode: string, taskCode: string}, session: BackendSession) {
+        let roleId = session.get('roleId');
+        let roleName = session.get('roleName');
+
+        let allFlag = !msg.taskCode;
+
+        const curTime = new Date();
+        const curTasks = await TowerTaskRecModel.getCurTasks(roleId);
+        if (!curTasks || curTasks.length == 0) {
+            return { code: 201, data: {msg: '没有可用派遣任务'}};
+        }
+        const compTasks = [];
+        let goods = [];
+        for (let task of curTasks) {
+            if (task.batchCode !== msg.batchCode) {
+                return { code: 201, data: {msg: '派遣编码错误'}};
+            }
+            if ((allFlag || task.taskCode === msg.taskCode) && task.status === 1) {
+                let {completeTime, reward, bonusCondition, bonus} = getTaskById(task.taskId);
+                if (task.sendTime && task.sendTime.getTime() + completeTime * 1000 < curTime.getTime()) {
+                    compTasks.push(task.taskCode);
+                    const rewardGoods = await handleFixedReward(roleId, roleName, reward, 1);
+                    goods = goods.concat(rewardGoods);
+                    if(bonusCondition) {
+                        const res = checkTaskConditions(roleId, task.heroes, bonusCondition);
+                        const bonusGoods = await handleFixedReward(roleId, roleName, bonus, 1);
+                        goods = goods.concat(bonusGoods);
+                    }
+                }
+            }
+        }
+        await TowerTaskRecModel.finishTask(msg.batchCode, compTasks);
+        return {
+            code: 200,
+            data: {
+                msg: '成功',
+                compTasks, goods
             }
         }
     }

game-server/app/services/battleService.ts

@@ -1,10 +1,11 @@
+import { HeroModel } from './../db/Hero';
 import { HangUpRecordModel } from './../db/HangUpRecord';
 import { ChannelService } from 'pinus';
 import { HANG_UP_CONSTS } from './../consts/consts';
 import { BattleRecordModel } from './../db/BattleRecord';
 import { TowerRecordModel } from './../db/TowerRecord';
 import { RoleModel } from './../db/Role';
-import { getTowerDataByLv } from "../util/gamedata"
+import { getHeroInfoById, getJobInfoById, getTowerDataByLv } from "../util/gamedata"
 import { decodeArrayStr, shouldRefresh } from '../util/util';
 import { handleFixedReward } from './rewardService';
 
@@ -119,4 +120,59 @@ export async function calcuHangUpReward(roleId: string, speedUp = false, speedUp
         timeReward: towerInfo.timeReward,
         multi
     };
+}
+
+async function checkCond(roleId: string, heroes, type: number, parm: number, cnt: number) {
+    let heroCnt = 0;
+
+    switch (type) {
+        case 1:
+            for(let hid of heroes) {
+                const rec = await HeroModel.findByHidAndRole(hid, roleId);
+                if (rec.star >= parm) {
+                    heroCnt++;
+                }
+            }
+            break;
+        case 2:
+            for(let hid of heroes) {
+                const hInfo = getHeroInfoById(hid);
+                if (hInfo.camp === parm) {
+                    heroCnt++;
+                }
+            }
+            break;
+        case 3:
+            for(let hid of heroes) {
+                const hInfo = getHeroInfoById(hid);
+                if (getJobInfoById(hInfo.jobid) === parm) {
+                    heroCnt++;
+                }
+            }
+            break;
+        default:
+            break;
+    }
+    if (heroCnt >= cnt) {
+        return true;
+    }
+    return false;
+}
+
+export async function checkTaskConditions(roleId: string, heroes: Array<number>, conditionsStr: string) {
+    const condArr = conditionsStr.split('|');
+    if (condArr.length < 1) return false;
+
+    let res = true;
+    for (let cond of condArr) {
+        const condDetail = cond.split('&');
+        if (condDetail && condDetail.length === 3) {
+            const checkRes = await checkCond(roleId, heroes, parseInt(condDetail[0]), parseInt(condDetail[1]), parseInt(condDetail[2]))
+            if (!checkRes) {
+                res = false;
+                break;
+            }
+        }
+    }
+    return res;
 }

game-server/app/util/gamedata.ts

@@ -7,6 +7,8 @@ const allWarInfos = new Map<number, any>();
 const towerInfos = new Map<number, any>();
 const towerTaskInfos = new Map<number, any>();
 const towerTasksByQuality = new Map<number, Array<number>>();
+const heroInfos = new Map<number, any>();
+const jobInfos = new Map<number, any>();
 
 function parseWarData() {
     let result = null;
@@ -44,6 +46,26 @@ function parseTowerTaskData() {
     });
 }
 
+function parseHeroData() {
+    const heroFile = 'dic_zyz_hero';
+    const heroesData = gamedata['jsons'][heroFile] || [];
+    heroesData.forEach(elem => {
+        if (elem && elem.heroId) {
+            heroInfos.set(elem.heroId, elem);
+        }
+    });
+}
+
+function parseJobData() {
+    const jobFile = 'dic_zyz_job';
+    const jobsData = gamedata['jsons'][jobFile] || [];
+    jobsData.forEach(elem => {
+        if (elem && elem.jobid) {
+            heroInfos.set(elem.jobid, elem);
+        }
+    });
+}
+
 function initData (folder) {
     if(!gamedata.hasOwnProperty(folder)) {
         gamedata[folder] = {};
@@ -71,6 +93,8 @@ function parseData() {
     parseWarData();
     parseTowerData();
     parseTowerTaskData();
+    parseHeroData();
+    parseJobData();
 }
 
 initData('jsons'); // 加载一般json
@@ -116,4 +140,14 @@ export function getTaskById(tid: number) {
 export function getTaskIdByQuality(quality: number) {
     const taskIds = towerTasksByQuality.get(quality);
     return taskIds;
+}
+
+export function getHeroInfoById(hid: number) {
+    const heroInfo = heroInfos.get(hid);
+    return heroInfo;
+}
+
+export function getJobInfoById(jid: number) {
+    const jobInfo = jobInfos.get(jid);
+    return jobInfo;
 }

game-server/app/util/util.ts

@@ -174,7 +174,7 @@ export function getRandEelm(source: Array<any> = [], cnt = 1): Array<any> {
   if (cnt > source.length) return null;
   if (cnt === source.length) return source;
   let idxs = new Set();
-  for (let i = 1; i < cnt; ++i) {
+  for (let i = 0; i < cnt; ++i) {
     let rand = Math.floor(Math.random() * source.length);
     idxs.add(rand);
     if (idxs.size == cnt) {