修改天梯和共斗的返回值

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

@@ -1,4 +1,6 @@
+import { STATUS } from './../../../consts/statusCode';
 import { Application, BackendSession } from 'pinus';
+import { resResult } from '../../../pubUtils/util';
 
 export default function(app: Application) {
     return new ComBattleHandler(app);
@@ -31,13 +33,7 @@ export class ComBattleHandler {
             sid: tsid
         }]);
 
-        return {
+        return resResult(STATUS.SUCCESS, { users, battleId });
-            code: 200,
-            data: {
-                users,
-                battleId
-            }
-        }
     }
 
     /**
@@ -59,17 +55,11 @@ export class ComBattleHandler {
         if (users.indexOf(roleId) === -1) {
             channel.add(roleId, sid);
         } else {
-            return {
+            return resResult(STATUS.COM_BATTLE_DUP_ENTER);
-                code: 202,
-                data: '不能重复加入'
-            };
         }
         channel.pushMessage('onAddBattle', {users});
 
-        return {
+        return resResult(STATUS.SUCCESS, { users });
-            code: 200,
-            data: users
-        }
     }
 
     async hurtHp(msg: {battleId: string, bossHurt: number, actorHurt: [{ actorId: number, actorHurt: number}]}, session: BackendSession) {
@@ -87,9 +77,6 @@ export class ComBattleHandler {
         }
         channel.pushMessage('bossHp', {bossHp: this.bossHp}, undefined);
 
-        return {
+        return resResult(STATUS.SUCCESS, { bossHp: this.bossHp});
-            code: 200,
-            data: this.bossHp
-        }
     }
 }

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

@@ -1,3 +1,4 @@
+import { STATUS } from './../../../consts/statusCode';
 import { TOWER_TASK_CONST } from './../../../consts/consts';
 import { TowerTaskRecModel } from './../../../db/TowerTaskRec';
 import { HangUpSpdUpRecModel } from './../../../db/HangUpSpdUpRec';
@@ -6,7 +7,7 @@ import { RoleModel } from './../../../db/Role';
 import { TowerRecordModel } from './../../../db/TowerRecord';
 import { Application, BackendSession } from 'pinus';
 import { getTaskById, getTaskIdByQuality, getTowerDataByLv } from '../../../pubUtils/gamedata';
-import { decodeArrayStr, decodeIdCntArrayStr, getRandEelm } from '../../../pubUtils/util';
+import { decodeArrayStr, decodeIdCntArrayStr, getRandEelm, resResult } from '../../../pubUtils/util';
 import { calcuHangUpReward, checkTaskConditions } from '../../../services/battleService';
 import { handleFixedReward } from '../../../services/rewardService';
 
@@ -36,18 +37,15 @@ export class TowerBattleHandler {
             const sts = decodeArrayStr(warIds).map(id => {
                 return {warId: parseInt(id), status: false};
             });
-            await TowerRecordModel.createRecord({roleId, lv: towerLv, warStatus: sts});
+            towerRec = await TowerRecordModel.createRecord({roleId, lv: towerLv, warStatus: sts});
-            return { code: 201, data: '天梯记录异常' };
+            // return { code: 201, data: '天梯记录异常' };
         }
         const data = {
             curLv: towerLv,
             usedHeroes: towerRec.heroes,
             progress: towerRec.warStatus
         };
-        return {
+        return resResult(STATUS.SUCCESS, data);
-            code: 200,
-            data
-        }
     }
 
     /**
@@ -59,34 +57,23 @@ export class TowerBattleHandler {
         let roleId = session.get('roleId');
         let { towerLv } = await RoleModel.findByRoleId(roleId);
         if (msg.towerLv !== towerLv) {
-            return {code: 201, data: '只能重置当前层'};
+            return resResult(STATUS.TOWER_RESET_ERR);
         }
         const record = await TowerRecordModel.resetRecordByLv(roleId, towerLv);
         if (!record) {
-            return { code: 201, data: '重置错误'};
+            return resResult(STATUS.TOWER_NOT_FOUND);
         }
-        return { code: 200, data: { record } };
+        return resResult(STATUS.SUCCESS, record);
     }
 
     async checkHangUpRewards(msg: {}, session: BackendSession) {
         let roleId = session.get('roleId');
         const { multi, timeReward } = await calcuHangUpReward(roleId);
         if (multi == 0) {
-            return {
+            return resResult(STATUS.TOWER_HANG_UP_NOT_VALID);
-                code: 201,
-                data: {
-                    msg: '尚未到可收取时间',
-                }
-            }
         }
         const rewards = decodeIdCntArrayStr(timeReward, multi);
-        return {
+        return resResult(STATUS.SUCCESS, {rewards: Array.from(rewards, item => ({[item[0]]: item[1]}))});
-            code: 200,
-            data: {
-                msg: '成功',
-                rewards: Array.from(rewards, item => ({[item[0]]: item[1]}))
-            }
-        };
     }
 
     async recHangUpRewards(msg: {}, session: BackendSession) {
@@ -94,64 +81,32 @@ export class TowerBattleHandler {
         let roleName = session.get('roleName');
         const { multi, timeReward, endLv, endTime } = await calcuHangUpReward(roleId);
         if (multi == 0) {
-            return {
+            return resResult(STATUS.TOWER_HANG_UP_NOT_VALID);
-                code: 201,
-                data: {
-                    msg: '尚未到可收取时间',
-                }
-            }
         }
         const goods = await handleFixedReward(roleId, roleName, timeReward, multi);
         const newRec = await HangUpRecordModel.updateRec(roleId, roleName, endLv, endTime);
-        return {
+        return resResult(STATUS.SUCCESS, { goods, hangUpRec: newRec });
-            code : 200,
-            data: {
-                msg: '成功',
-                goods, hangUpRec: newRec
-            }
-        }
     }
 
     async hangUpSpeedUp(msg: {speedUpCnt: number}, session: BackendSession) {
         let roleId = session.get('roleId');
         let roleName = session.get('roleName');
         if (msg.speedUpCnt <= 0) {
-            return {
+            return resResult(STATUS.WRONG_PARMS);
-                code: 201,
-                data: {
-                    msg: '加速参数错误',
-                }
-            };
         }
         const curTime = new Date();
         const { multi, timeReward, endLv } = await calcuHangUpReward(roleId, true, msg.speedUpCnt, curTime);
         if (multi <= 0) {
-            return {
+            resResult(STATUS.TOWER_NOT_ENOUGH_HANG_UP_TIME);
-                code: 201,
-                data: {
-                    msg: '今日加速次数不足'
-                }
-            };
         }
 
         const role = await RoleModel.hangUpSpdUp(roleId, multi, curTime);
         if (!role) {
-            return {
+            return resResult(STATUS.TOWER_HANG_UP_FAILED);
-                code: 201,
-                data: {
-                    msg: '不满足加速条件'
-                }
-            };
         }
         const spdUpRec = await HangUpSpdUpRecModel.updateRec(roleId, roleName, multi, endLv);
         const goods = await handleFixedReward(roleId, roleName, timeReward, multi);
-        return {
+        return resResult(STATUS.SUCCESS, { goods, rewardLv: endLv, spdUpRec });
-            code : 200,
-            data: {
-                msg: '成功',
-                goods, rewardLv: endLv, spdUpRec
-            }
-        };
     }
 
     async getTasks(msg: {}, session: BackendSession) {
@@ -167,20 +122,14 @@ export class TowerBattleHandler {
             })
             curTasks = await TowerTaskRecModel.createTasks(roleId, roleName, taskIds);
         }
-        return {
+        return resResult(STATUS.SUCCESS, { curTasks });
-            code: 200,
-            data: {
-                msg: '成功',
-                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: '没有可用派遣任务'}};
+            return resResult(STATUS.TOWER_TASK_NOT_FOUND);
         }
         let usedHeroes = [];
         const tasksCode = [];
@@ -190,7 +139,7 @@ export class TowerBattleHandler {
         });
         for (let task of msg.tasks) {
             if (task.heroes.length > TOWER_TASK_CONST.MAX_HEROES_NUM) {
-                return { code: 201, data: {msg: '一个任务最多派遣三个武将'}};
+                return resResult(STATUS.TOWER_TASK_MAX_HERO);
             }
             if (usedHeroes.length > 0) {
                 let used = false;
@@ -200,25 +149,19 @@ export class TowerBattleHandler {
                     }
                 })
                 if (used) {
-                    return { code: 201, data: {msg: '武将已经派遣到其他任务'}};
+                    return resResult(STATUS.TOWER_TASK_HERO_HAS_USED);
                 }
             }
             if (tasksCode.indexOf(task.taskCode) === -1) {
-                return { code: 201, data: {msg: '未找到此任务编号'}};
+                return resResult(STATUS.TOWER_TASK_CODE_NOT_FOUND);
             }
         }
         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 resResult(STATUS.TOWER_TASK_SEND_ERR);
-        }
-        return {
-            code: 200,
-            data: {
-                msg: '派遣成功',
-                tasks: recs
-            }
         }
+        return resResult(STATUS.SUCCESS, { tasks: recs });
     }
 
     async settleTask(msg: {batchCode: string, taskCode: string}, session: BackendSession) {
@@ -230,13 +173,13 @@ export class TowerBattleHandler {
         const curTime = new Date();
         const curTasks = await TowerTaskRecModel.getCurTasks(roleId);
         if (!curTasks || curTasks.length == 0) {
-            return { code: 201, data: {msg: '没有可用派遣任务'}};
+            return resResult(STATUS.TOWER_TASK_NOT_FOUND);
         }
         const compTasks = [];
         let goods = [];
         for (let task of curTasks) {
             if (task.batchCode !== msg.batchCode) {
-                return { code: 201, data: {msg: '派遣编码错误'}};
+                return resResult(STATUS.TOWER_TASK_BATCH_NOT_FOUND);
             }
             if ((allFlag || task.taskCode === msg.taskCode) && task.status === 1) {
                 let {completeTime, reward, bonusCondition, bonus} = getTaskById(task.taskId);
@@ -253,12 +196,6 @@ export class TowerBattleHandler {
             }
         }
         await TowerTaskRecModel.finishTask(msg.batchCode, compTasks);
-        return {
+        return resResult(STATUS.SUCCESS, { compTasks, goods });
-            code: 200,
-            data: {
-                msg: '成功',
-                compTasks, goods
-            }
-        }
     }
 }

shared/consts/statusCode.ts

@@ -49,7 +49,18 @@ export const STATUS = {
     TOWER_WRONG_BATTLE_ID: { code: 20503, simStr: '战斗 Id 异常' },
     TOWER_DUPLICATE_HERO: { code: 20504, simStr: '使用了重复的武将' },
     TOWER_DUPLICATE_CHALLENGE: { code: 20505, simStr: '天梯关卡不能重复挑战' },
-    
+    TOWER_NOT_FOUND: { code: 20506, simStr: '没有找到合适的天梯记录' },
+    TOWER_HANG_UP_NOT_VALID: { code: 20507, simStr: '尚未到可收取时间' },
+    TOWER_NOT_ENOUGH_HANG_UP_TIME: { code: 20508, simStr: '今日加速次数不足' },
+    TOWER_HANG_UP_FAILED: { code: 20509, simStr: '不满足加速条件' },
+    TOWER_TASK_NOT_FOUND: { code: 20510, simStr: '没有可用派遣任务' },
+    TOWER_TASK_MAX_HERO: { code: 20511, simStr: '超过派遣武将最大人数' },
+    TOWER_TASK_HERO_HAS_USED: { code: 20512, simStr: '武将已经派遣到其他任务' },
+    TOWER_TASK_CODE_NOT_FOUND: { code: 20513, simStr: '未找到此任务编号' },
+    TOWER_TASK_SEND_ERR: { code: 20514, simStr: '任务派遣失败，请检查任务编号' },
+    TOWER_TASK_BATCH_NOT_FOUND: { code: 20515, simStr: '派遣编码错误' },
+    // 共斗 20600 - 20699
+    COM_BATTLE_DUP_ENTER: { code: 20601, simStr: '不能重复加入' },
     // 养成相关状态 30000 - 39999
     // 社交相关状态 40000 - 49999
     // 运营模块相关状态 50000 - 59999