269 lines
12 KiB
TypeScript
269 lines
12 KiB
TypeScript
import { STATUS } from './../../../consts/statusCode';
|
|
import { HANG_UP_CONSTS, GOLD_COST_RATIO, TOWER_TASK_CONST } from './../../../consts/consts';
|
|
import { TowerTaskRecModel } 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 { getTaskById, getTowerDataByLv } from '../../../pubUtils/gamedata';
|
|
import { decodeArrayStr, resResult, shouldRefresh, calculateNum } from '../../../pubUtils/util';
|
|
import { calcuHangUpReward, checkTaskConditions, checkHangUpSpdUpCnt, createCurTasks, treatTask, getRemainTime, getTasksReward } from '../../../services/battleService';
|
|
import { handleFixedReward, handleReward } from '../../../services/rewardService';
|
|
|
|
export default function(app: Application) {
|
|
return new TowerBattleHandler(app);
|
|
}
|
|
|
|
export class TowerBattleHandler {
|
|
constructor(private app: Application) {
|
|
}
|
|
|
|
/**
|
|
* 获取天梯当前挑战状态
|
|
* @param session
|
|
*/
|
|
async getStatus(msg: {}, session: BackendSession) {
|
|
let roleId = session.get('roleId');
|
|
let { towerLv } = await RoleModel.findByRoleId(roleId);
|
|
if (!towerLv) {
|
|
towerLv = 1;
|
|
await RoleModel.towerLvUp(roleId);
|
|
}
|
|
let towerRec = await TowerRecordModel.getRecordByLv(roleId, towerLv);
|
|
if (!towerRec) {
|
|
const towerInfo = getTowerDataByLv(towerLv);
|
|
const { warArray } = towerInfo;
|
|
const sts = decodeArrayStr(warArray, '&').map(id => {
|
|
return {warId: parseInt(id), status: false};
|
|
});
|
|
towerRec = await TowerRecordModel.createRecord({roleId, lv: towerLv, warStatus: sts});
|
|
// return { code: 201, data: '天梯记录异常' };
|
|
}
|
|
const data = {
|
|
curLv: towerLv,
|
|
usedHeroes: towerRec.heroes,
|
|
progress: towerRec.warStatus
|
|
};
|
|
return resResult(STATUS.SUCCESS, data);
|
|
}
|
|
|
|
/**
|
|
* 重置天梯当前层的挑战记录
|
|
* @param towerLv 要重置的天梯层数
|
|
* @param session
|
|
*/
|
|
async resetLv(msg: {towerLv: number}, session: BackendSession) {
|
|
let roleId = session.get('roleId');
|
|
let { towerLv } = await RoleModel.findByRoleId(roleId);
|
|
if (msg.towerLv !== towerLv) {
|
|
return resResult(STATUS.TOWER_RESET_ERR);
|
|
}
|
|
const record = await TowerRecordModel.resetRecordByLv(roleId, towerLv);
|
|
if (!record) {
|
|
return resResult(STATUS.TOWER_NOT_FOUND);
|
|
}
|
|
return resResult(STATUS.SUCCESS, record);
|
|
}
|
|
|
|
async checkHangUpRewards(msg: {}, session: BackendSession) {
|
|
let roleId = session.get('roleId');
|
|
const result = await calcuHangUpReward(roleId);
|
|
if(result.status == -1) {
|
|
return result.resResult
|
|
}
|
|
let {timeReward, startTime, deltaTime} = result.data;
|
|
return resResult(STATUS.SUCCESS, {startTime, hangUpPassTime: deltaTime, rewards: timeReward.map(cur => {return {id: cur.gid, count: cur.count}})});
|
|
}
|
|
|
|
async recHangUpRewards(msg: {}, session: BackendSession) {
|
|
let roleId = session.get('roleId');
|
|
let roleName = session.get('roleName');
|
|
const result = await calcuHangUpReward(roleId);
|
|
if(result.status == -1) {
|
|
return result.resResult
|
|
}
|
|
let { timeReward, endLv, endTime, deltaTime, needReceiveGoods } = result.data;
|
|
|
|
const goods = await handleReward(roleId, roleName, timeReward);
|
|
await HangUpRecordModel.updateRec(roleId, roleName, endLv, endTime, needReceiveGoods);
|
|
|
|
return resResult(STATUS.SUCCESS, { endTime, hangUpPassTime: deltaTime%HANG_UP_CONSTS.MAX_TIME, ...goods });
|
|
}
|
|
|
|
async hangUpSpeedUp(msg: {speedUpCnt: number}, session: BackendSession) {
|
|
let roleId = session.get('roleId');
|
|
let roleName = session.get('roleName');
|
|
if (msg.speedUpCnt <= 0) {
|
|
return resResult(STATUS.WRONG_PARMS);
|
|
}
|
|
const curTime = new Date();
|
|
const calResult = await calcuHangUpReward(roleId, true, msg.speedUpCnt, curTime);
|
|
if(calResult.status == -1) {
|
|
return calResult.resResult;
|
|
}
|
|
let { timeReward, endLv, deltaTime, needReceiveGoods } = calResult.data;
|
|
|
|
let result = await checkHangUpSpdUpCnt(roleId, msg.speedUpCnt, curTime);
|
|
if(result.status == -1) return result.resResult;
|
|
let {data: {hangUpSpdUpCnt, gold}} = result;
|
|
|
|
const costGold = this.getHangUpCost(hangUpSpdUpCnt, msg.speedUpCnt);
|
|
if(costGold > gold) {
|
|
return resResult(STATUS.TOWER_GOLD_NOT_ENOUGH);
|
|
}
|
|
await RoleModel.costGold(roleId, costGold);
|
|
|
|
const spdUpResult = await RoleModel.hangUpSpdUp(roleId, msg.speedUpCnt, curTime);
|
|
if (!spdUpResult) {
|
|
return resResult(STATUS.TOWER_HANG_UP_FAILED);
|
|
}
|
|
const spdUpRec = await HangUpSpdUpRecModel.updateRec(roleId, roleName, msg.speedUpCnt, endLv, needReceiveGoods);
|
|
const goods = await handleReward(roleId, roleName, timeReward);
|
|
return resResult(STATUS.SUCCESS, { ...goods, hangUpPassTime: deltaTime, rewardLv: endLv, costGold });
|
|
}
|
|
|
|
getHangUpCost(originCnt: number, count: number) {
|
|
let gold = 0;
|
|
for(let i = 1; i <= count; i++) {
|
|
let num = HANG_UP_CONSTS.MAX_SPD_UP_CNT - originCnt + i;
|
|
if(num < 0) num = i;
|
|
gold += calculateNum(GOLD_COST_RATIO.TOWER_HANG_SPDUP, {num}, 50);
|
|
}
|
|
return gold
|
|
}
|
|
|
|
async getTasks(msg: {}, session: BackendSession) {
|
|
let roleId = session.get('roleId');
|
|
let roleName = session.get('roleName');
|
|
let curTime = new Date();
|
|
let { towerLv, towerTaskReCnt = 0, towerTaskRefTime = curTime } = await RoleModel.findByRoleId(roleId);
|
|
let needRefresh = shouldRefresh(towerTaskRefTime, curTime, TOWER_TASK_CONST.REFRESH_TIME);
|
|
if(needRefresh) {
|
|
towerTaskReCnt = 0;
|
|
}
|
|
let costGold = calculateNum(GOLD_COST_RATIO.TPWER_TASK_REF, {num: towerTaskReCnt}, 200);
|
|
let curTasks = await TowerTaskRecModel.getCurTasks(roleId);
|
|
if (!curTasks || curTasks.length == 0) {
|
|
curTasks = await createCurTasks(towerLv, roleId, roleName);
|
|
}
|
|
let refRemainTime = getRemainTime(curTime);
|
|
|
|
return resResult(STATUS.SUCCESS, { curTasks: treatTask(curTasks, curTime), refRemainTime, nextCostGold: costGold });
|
|
}
|
|
|
|
async refreshTasks(msg: {}, session: BackendSession) {
|
|
let roleId = session.get('roleId');
|
|
let roleName = session.get('roleName');
|
|
let curTime = new Date();
|
|
let { towerLv, towerTaskReCnt = 0, towerTaskRefTime = curTime } = await RoleModel.findByRoleId(roleId);
|
|
let needRefresh = shouldRefresh(towerTaskRefTime, curTime, TOWER_TASK_CONST.REFRESH_TIME);
|
|
if(needRefresh) {
|
|
towerTaskReCnt = 0;
|
|
}
|
|
let costGold = calculateNum(GOLD_COST_RATIO.TPWER_TASK_REF, {num: towerTaskReCnt}, 200);
|
|
let {gold} = await RoleModel.findByRoleId(roleId);
|
|
if(costGold > gold) {
|
|
return resResult(STATUS.TOWER_GOLD_NOT_ENOUGH);
|
|
}
|
|
await RoleModel.increaseTowerRefCnt(roleId, needRefresh, curTime);
|
|
|
|
// tmp: 将刷掉的旧任务的奖励发送到邮件中
|
|
let oldReward = await getTasksReward(roleId, curTime);
|
|
console.log(JSON.stringify(oldReward));
|
|
await TowerTaskRecModel.refreshTask(roleId); // 刷掉旧的任务
|
|
|
|
|
|
let curTasks = await createCurTasks(towerLv, roleId, roleName); // 刷出新的任务
|
|
|
|
let nextCostGold = calculateNum(GOLD_COST_RATIO.TPWER_TASK_REF, {num: towerTaskReCnt + 1}, 200);
|
|
return resResult(STATUS.SUCCESS, { curTasks: treatTask(curTasks, curTime), costGold, nextCostGold});
|
|
}
|
|
|
|
async sendTaskHero(msg: {batchCode: string, tasks: Array<{taskCode: string, heroes: Array<number>}>}, session: BackendSession) {
|
|
let roleId = session.get('roleId');
|
|
|
|
const curTime = new Date();
|
|
const curTasks = await TowerTaskRecModel.getCurTasks(roleId); // 当前一批的任务
|
|
if (!curTasks || curTasks.length == 0) {
|
|
return resResult(STATUS.TOWER_TASK_NOT_FOUND);
|
|
}
|
|
let usedHeroes = [], tasks = [];
|
|
const tasksCode = [];
|
|
const taskMap = new Map<string, any>()
|
|
curTasks.forEach(task => {
|
|
usedHeroes = usedHeroes.concat(task.heroes);
|
|
tasksCode.push(task.taskCode);
|
|
taskMap.set(task.taskCode, task);
|
|
});
|
|
for (let task of msg.tasks) {
|
|
let curTask = taskMap.get(task.taskCode); // 数据库中，这个任务的数据
|
|
if(!curTask) {
|
|
return resResult(STATUS.TOWER_TASK_MISSING)
|
|
}
|
|
let taskInfo = getTaskById(curTask.taskId);
|
|
if (task.heroes.length > taskInfo.actorNeeded) { // 武将数，从策划表中读取
|
|
return resResult(STATUS.TOWER_TASK_MAX_HERO);
|
|
}
|
|
if (tasksCode.indexOf(task.taskCode) === -1) {
|
|
return resResult(STATUS.TOWER_TASK_CODE_NOT_FOUND);
|
|
}
|
|
if (usedHeroes.length > 0) { // 是否在其他任务重使用了武将
|
|
let used = !!task.heroes.find(hid => usedHeroes.indexOf(hid) !== -1);
|
|
if (used) {
|
|
return resResult(STATUS.TOWER_TASK_HERO_HAS_USED);
|
|
}
|
|
}
|
|
tasks.push({...task, completeTime: taskInfo.completeTime})
|
|
|
|
}
|
|
const recs = await TowerTaskRecModel.sendHeroes(roleId, msg.batchCode, tasks, curTime,);
|
|
if (!recs || recs.length === 0) {
|
|
return resResult(STATUS.TOWER_TASK_SEND_ERR);
|
|
}
|
|
return resResult(STATUS.SUCCESS, { tasks: treatTask(recs, curTime) });
|
|
}
|
|
|
|
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 resResult(STATUS.TOWER_TASK_NOT_FOUND);
|
|
}
|
|
const compTasks = [];
|
|
let goods = [];
|
|
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} = 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.goods);
|
|
if(termsForAdd) {
|
|
const result = checkTaskConditions(roleId, task.heroes, termsForAdd);
|
|
const bonusGoods = await handleFixedReward(roleId, roleName, result?additionalReward:'', 1);
|
|
goods = goods.concat(bonusGoods.goods);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const rec = await TowerTaskRecModel.finishTask(msg.batchCode, compTasks);
|
|
return resResult(STATUS.SUCCESS, { compTasks: treatTask(rec, curTime), goods });
|
|
}
|
|
|
|
|
|
async getTowerRank(msg: {}, session: BackendSession) {
|
|
let ranks = await RoleModel.getRank('tower', ['roleId', 'roleName', 'towerLv', 'lv', 'vLv']);
|
|
|
|
return resResult(STATUS.SUCCESS, { ranks });
|
|
}
|
|
}
|