xinyuxi/ZYZ
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix 联调时遇到的问题

Browse Source
This commit is contained in:
luying
2020-11-05 19:33:39 +08:00
parent ff6b8bcdca
commit bd93d9dc1c
12 changed files with 598 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
game-server/app/servers/battle/handler/dailyBattleHandler.ts
View File

@@ -2,9 +2,9 @@ import { Application, BackendSession } from 'pinus';
import { DailyRecordModel } from '../../../db/DailyRecord';
import { BattleRecordModel } from '../../../db/BattleRecord';
import { getGamedata } from '../../../pubUtils/gamedata';
import { WAR_TYPE, GONGSHI } from '../../../consts/consts';
import { WAR_TYPE, GOLD_COST_RATIO } from '../../../consts/consts';
import { STATUS } from '../../../consts/statusCode';
import { resResult } from '../../../pubUtils/util';
import { resResult, calculateNum } from '../../../pubUtils/util';
import { RoleModel } from '../../../db/Role';
import { getDailyNum } from '../../../services/dailyBattleService';
@@ -53,8 +53,7 @@ export class DailyBattleHandler {
});
}
}
let checkDailyResult = getDailyNum(refreshResult, timesPerDay, timesCanBuy);
let checkDailyResult = await getDailyNum(refreshResult, timesPerDay, timesCanBuy);
result.push({
type, name, ...checkDailyResult,
wars
@@ -84,7 +83,7 @@ export class DailyBattleHandler {
let buyCost = 0;
for(let i = 1; i <= count; i++) {
let num = buyCount + i;
buyCost += eval(GONGSHI.DAILY_REFRESH_NUM_COST);
buyCost += calculateNum(GOLD_COST_RATIO.DAILY_REF_NUM, {num}, 50);
}
let {gold} = await RoleModel.findByRoleId(roleId);
if(buyCost > gold) {
@@ -94,7 +93,7 @@ export class DailyBattleHandler {
let newDailyRecord = await DailyRecordModel.increseBuyCount(roleId, type, count);
console.log(buyCost);
let checkDailyResult = getDailyNum(newDailyRecord, timesPerDay, timesCanBuy);
let checkDailyResult = await getDailyNum(newDailyRecord, timesPerDay, timesCanBuy);
return resResult(STATUS.SUCCESS, { type, ...checkDailyResult, buyCost});
}
}

101
game-server/app/servers/battle/handler/towerBattleHandler.ts
View File

@@ -1,14 +1,14 @@
import { STATUS } from './../../../consts/statusCode';
import { TOWER_TASK_CONST, HANG_UP_CONSTS, GONGSHI } from './../../../consts/consts';
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, getTaskIdByFloor, getTowerDataByLv } from '../../../pubUtils/gamedata';
import { decodeArrayStr, decodeIdCntArrayStr, getRandEelm, resResult, shouldRefresh, getRandomWithWeight } from '../../../pubUtils/util';
import { calcuHangUpReward, checkTaskConditions, checkHangUpSpdUpCnt } from '../../../services/battleService';
import { getTaskById, getTowerDataByLv } from '../../../pubUtils/gamedata';
import { decodeArrayStr, resResult, shouldRefresh, calculateNum } from '../../../pubUtils/util';
import { calcuHangUpReward, checkTaskConditions, checkHangUpSpdUpCnt, createCurTasks, treatTask, getRemainTime } from '../../../services/battleService';
import { handleFixedReward, handleReward } from '../../../services/rewardService';
export default function(app: Application) {
@@ -68,18 +68,27 @@ export class TowerBattleHandler {
async checkHangUpRewards(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
const { timeReward, startTime, deltaTime } = await calcuHangUpReward(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 { timeReward, endLv, endTime, deltaTime, needReceiveGoods } = await calcuHangUpReward(roleId);
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, ...goods });
return resResult(STATUS.SUCCESS, { endTime, hangUpPassTime: deltaTime%HANG_UP_CONSTS.MAX_TIME, ...goods });
}
async hangUpSpeedUp(msg: {speedUpCnt: number}, session: BackendSession) {
@@ -89,7 +98,11 @@ export class TowerBattleHandler {
return resResult(STATUS.WRONG_PARMS);
}
const curTime = new Date();
const { timeReward, endLv, deltaTime, needReceiveGoods } = await calcuHangUpReward(roleId, true, msg.speedUpCnt, curTime);
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;
@@ -117,11 +130,7 @@ export class TowerBattleHandler {
for(let i = 1; i <= count; i++) {
let num = HANG_UP_CONSTS.MAX_SPD_UP_CNT - originCnt + i;
if(num < 0) num = i;
try {
gold += parseInt(eval(GONGSHI.TOWER_HANG_UP_SPEED_COST));
} catch(e) {
gold += 0;
}
gold += calculateNum(GOLD_COST_RATIO.TOWER_HANG_SPDUP, {num}, 50);
}
return gold
}
@@ -129,33 +138,54 @@ export class TowerBattleHandler {
async getTasks(msg: {}, session: BackendSession) {
let roleId = session.get('roleId');
let roleName = session.get('roleName');
let { towerLv } = await RoleModel.findByRoleId(roleId);
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) {
let taskIds = [];
const taskList = getTaskIdByFloor(towerLv)||[];
const randomList = taskList.map(taskId => getTaskById(taskId));
for(let i = 0; i < TOWER_TASK_CONST.RAND_CNT; i++) {
let list = randomList.filter(taskId => !taskIds.includes(taskId));
console.log(taskIds, JSON.stringify(list));
let {dic: tmp} = getRandomWithWeight(list);
if(tmp) {
taskIds.push(tmp.taskId);
}
}
curTasks = await TowerTaskRecModel.createTasks(roleId, roleName, taskIds);
curTasks = await createCurTasks(towerLv, roleId, roleName);
}
return resResult(STATUS.SUCCESS, { curTasks });
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);
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 = [];
let usedHeroes = [], tasks = [];
const tasksCode = [];
const taskMap = new Map<string, any>()
curTasks.forEach(task => {
@@ -165,6 +195,9 @@ export class TowerBattleHandler {
});
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);
@@ -178,14 +211,14 @@ export class TowerBattleHandler {
return resResult(STATUS.TOWER_TASK_HERO_HAS_USED);
}
}
tasks.push({...task, completeTime: taskInfo.completeTime})
}
const curTime = new Date();
const recs = await TowerTaskRecModel.sendHeroes(roleId, msg.batchCode, msg.tasks, curTime);
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: recs });
return resResult(STATUS.SUCCESS, { tasks: treatTask(recs, curTime) });
}
async settleTask(msg: {batchCode: string, taskCode: string}, session: BackendSession) {
@@ -219,7 +252,7 @@ export class TowerBattleHandler {
}
}
}
await TowerTaskRecModel.finishTask(msg.batchCode, compTasks);
return resResult(STATUS.SUCCESS, { compTasks, goods });
const rec = await TowerTaskRecModel.finishTask(msg.batchCode, compTasks);
return resResult(STATUS.SUCCESS, { compTasks: treatTask(rec, curTime), goods });
}
}

68
game-server/app/services/battleService.ts
View File

@@ -1,15 +1,17 @@
import { HeroModel } from './../db/Hero';
import { HangUpRecordModel } from './../db/HangUpRecord';
import { ChannelService } from 'pinus';
import { HANG_UP_CONSTS } from './../consts/consts';
import { HANG_UP_CONSTS, TOWER_TASK_CONST } from './../consts/consts';
import { BattleRecordModel } from './../db/BattleRecord';
import { TowerRecordModel } from './../db/TowerRecord';
import { RoleModel } from './../db/Role';
import { getHeroInfoById, getJobInfoById, getTowerDataByLv } from "../pubUtils/gamedata"
import { decodeArrayStr, shouldRefresh, resResult, decodeStr, cal } from '../pubUtils/util';
import { getHeroInfoById, getJobInfoById, getTowerDataByLv, getTaskById, getTaskIdByFloor } from "../pubUtils/gamedata"
import { decodeArrayStr, shouldRefresh, resResult, decodeStr, cal, getRandomWithWeight, getRefTime } from '../pubUtils/util';
import { handleFixedReward } from './rewardService';
import { STATUS } from '../consts/statusCode';
import { HangUpSpdUpRecModel } from '../db/HangUpSpdUpRec';
import TowerTaskRec, { TowerTaskRecModel } from '../db/TowerTaskRec';
import { PvpDefenseModel } from '../db/PvpDefense';
export async function checkTowerWar(roleId: string, battleId: number, heroes: Array<number>) {
const battleIdStr = `${battleId}`;
@@ -114,6 +116,9 @@ export async function checkHangUpSpdUpCnt(roleId: string, cnt: number, curTime:
export async function calcuHangUpReward(roleId: string, speedUp = false, speedUpCnt = 1, curTime = new Date()) {
let { towerLv = 1, hangUpSpdUpCnt = 0, lastSpdUpTime } = await RoleModel.findByRoleId(roleId);
if(towerLv < HANG_UP_CONSTS.ENABLE_LV) {
return {status: -1, resResult: resResult(STATUS.TOWER_HANG_UP_NOT_START)}
}
let towerInfo = getTowerDataByLv(towerLv - 1); // towerLv 是当前层，奖励计算按照已经通过的层，即上一层
let timeReward = []; // 奖励
@@ -175,12 +180,15 @@ export async function calcuHangUpReward(roleId: string, speedUp = false, speedUp
}
}
return {
endLv: towerLv - 1,
startTime,
deltaTime,
endTime,
timeReward,
needReceiveGoods
status: 0,
data: {
endLv: towerLv - 1,
startTime,
deltaTime,
endTime,
timeReward,
needReceiveGoods
}
};
}
@@ -236,3 +244,45 @@ export async function checkTaskConditions(roleId: string, heroes: Array<number>,
return res;
}
/**
* 创建新的派遣任务
* @param towerLv 玩家层数
* @param roleId 玩家id
* @param roleName 玩家名
*/
export async function createCurTasks(towerLv: number, roleId: string, roleName: string) {
let taskIds = [];
const taskList = getTaskIdByFloor(towerLv)||[];
const randomList = taskList.map(taskId => getTaskById(taskId));
for(let i = 0; i < TOWER_TASK_CONST.RAND_CNT; i++) {
let list = randomList.filter(cur => !taskIds.includes(cur.taskId));
let {dic: tmp} = getRandomWithWeight(list);
if(tmp) {
taskIds.push(tmp.taskId);
}
}
const curTasks = await TowerTaskRecModel.createTasks(roleId, roleName, taskIds);
return curTasks
}
export function getRemainTime(curTime: Date) {
let nextTime = getRefTime(curTime, TOWER_TASK_CONST.REFRESH_TIME, 1);
return Math.floor((nextTime.getTime() - curTime.getTime())/1000);
}
export function treatTask(recs: Array<any>, curTime: Date) {
return recs.map(cur => {
let { heroes, batchCode, taskId, taskCode, status, completeTime} = cur;
let remainTime = 0;
if(status == 1) {
console.log(curTime.getTime(), completeTime.getTime())
remainTime = Math.floor((completeTime.getTime() - curTime.getTime())/1000);
if(remainTime < 0) {
status = 2; remainTime = 0;
}
}
return { heroes, batchCode, taskId, taskCode, status, completeTime, remainTime }
});
}

4
game-server/app/services/dailyBattleService.ts
View File

@@ -23,7 +23,7 @@ export async function checkDaily(roleId: string, battleId: number, inc: number)
if(count + inc > curDaily.timesPerDay + buyCount ) {
return { status: -1, resResult: resResult(STATUS.DAILY_TIMES_LACK) }
}
let checkDailyResult = getDailyNum(curDaily, curDaily.timesPerDay, curDaily.timesCanBuy);
let checkDailyResult = await getDailyNum(dailyRecord, curDaily.timesPerDay, curDaily.timesCanBuy);
return {status: 1, data: {type, ...checkDailyResult}};
}
@@ -56,7 +56,7 @@ export async function checkDailyAndIncrease(roleId: string, battleId: number, in
return { status: -1, resResult: resResult(STATUS.DAILY_TIMES_LACK) }
}
let result = await DailyRecordModel.increseDailyCount(roleId, type, inc);
let checkDailyResult = getDailyNum(result, curDaily.timesPerDay, curDaily.timesCanBuy);
let checkDailyResult = await getDailyNum(result, curDaily.timesPerDay, curDaily.timesCanBuy);
return {status: 1, data: {type, ...checkDailyResult}};
}