名将擂台：获取对手

2022-07-15 15:31:08 +08:00
parent 7394f14e9d
commit f56dbc29de
15 changed files with 1881 additions and 70 deletions
--- a/game-server/app/servers/battle/handler/ladderHandler.ts
+++ b/game-server/app/servers/battle/handler/ladderHandler.ts
@@ -1,18 +1,18 @@

 import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
 import { uniq, findWhere, findIndex, pick } from 'underscore';
-import { gameData, getPvpBoxBySeasonNumAndIndex } from '../../../pubUtils/data';
+import { gameData, getDicLadderMatchByMyRank, getPvpBoxBySeasonNumAndIndex } from '../../../pubUtils/data';
 import { RoleModel, RoleType } from '../../../db/Role';
 import { STATUS } from '../../../consts/statusCode';
 import { resResult, genCode, checkRoleIsRobot, robotIdComBack } from '../../../pubUtils/util';
 import { LadderMatchModel, LadderUpdateInter } from '../../../db/LadderMatch';
-import { getBuyCntCost, getLadderData, refreshLadderDaily } from '../../../services/ladderService';
-import { LadderDataReturn, LadderDefense, LadderDefenseHero } from '../../../domain/battleField/ladder';
+import { checkRank, generateInitRecInfo, getBuyCntCost, getLadderData, getLadderOppStatus, refreshLadderDaily, refreshLadderEnemies } from '../../../services/ladderService';
+import { LadderDataReturn, LadderDefense, LadderDefenseHero, LadderOppLineupReturn, LadderOppPlayerInfo } from '../../../domain/battleField/ladder';
 import { LadderMatchRecModel } from '../../../db/LadderMatchRec';
 import { HeroModel, HeroType } from '../../../db/Hero';
 import { LADDER } from '../../../pubUtils/dicParam';
 import { handleCost } from '../../../services/role/rewardService';
-import { ITEM_CHANGE_REASON } from '../../../consts';
+import { ITEM_CHANGE_REASON, LADDER_CHECK_STOP_TIME, LADDER_OPP_STATUS, LADDER_STATUS } from '../../../consts';

 export default function (app: Application) {
    new HandlerService(app, {});
@@ -23,7 +23,7 @@ export class LadderHandler {
    constructor(private app: Application) {
    }

-    //1获取主界面
+    // 1. 获取主界面
    async getData(msg: {}, session: BackendSession) {
        let roleId = session.get('roleId');
 
@@ -31,7 +31,132 @@ export class LadderHandler {
        return resResult(STATUS.SUCCESS, result);
    }

-    // 8. 设置防守阵容
+    // 2. 获取对手阵容信息
+    async getOppLineup(msg: { roleId: string, rank: number }, session: BackendSession) {
+        let roleId = session.get('roleId');
+        let { roleId: targetRoleId, rank } = msg;
+
+        let ladderData = await LadderMatchModel.findByRoleId(roleId);
+        if(!ladderData) return resResult(STATUS.LADDER_NOT_OPEN);
+        if(!checkRank(ladderData.rank, rank)) return resResult(STATUS.LADDER_RANK_ERROR);
+
+        let { oppPlayers = [] } = ladderData;
+        let curOppPlayer = oppPlayers.find(cur => cur.roleId == targetRoleId);
+        let isRobot = curOppPlayer? curOppPlayer.isRobot: false;
+        let result = new LadderOppLineupReturn();
+        result.setMyRank(ladderData.rank);
+        if(isRobot) {
+            let dicLadderDifficultRatio = gameData.ladderDifficultRatio.get(rank);
+            let dicWarJson = gameData.warJson.get(dicLadderDifficultRatio.gkId);
+            result.setRobot(dicLadderDifficultRatio, dicWarJson);
+        } else {
+            let hisLadderData = await LadderMatchModel.findByRoleIdAndInclude(targetRoleId);
+            result.setPlayer(hisLadderData);
+        }
+        return resResult(STATUS.SUCCESS, result);
+    }
+
+    // 3. 点击挑战
+    async chooseOpp(msg: { roleId: string, rank: number, myRank: number }, session: BackendSession) {
+        let roleId = session.get('roleId');
+        let serverId = session.get('serverId');
+        let { roleId: targetRoleId, rank, myRank } = msg;
+        // 检查双方排名等，不行的刷新对手回去
+        let ladderData = await LadderMatchModel.findByRoleIdAndInclude(roleId);
+        if(!ladderData) return resResult(STATUS.LADDER_NOT_OPEN);
+        
+        let { status, isRobot, hisLadderData } = await getLadderOppStatus(ladderData, targetRoleId, myRank, rank);
+        if(status != LADDER_OPP_STATUS.BATTLE) {
+            let oppPlayers = await refreshLadderEnemies(ladderData);
+            return resResult(STATUS.SUCCESS, {
+                status, oppPlayers
+            });
+        }
+
+        // 创建ladderMatchRec，发行battleCode
+        let attackInfo = generateInitRecInfo(false, false, ladderData.rank, ladderData);
+        let defenseInfo = generateInitRecInfo(isRobot, true, rank, hisLadderData);
+        let rec = await LadderMatchRecModel.createRec(serverId, roleId, targetRoleId, hisLadderData?.defense, attackInfo, defenseInfo);
+
+        // 倒计时，倒计时结束没有check设为失败并发失败通知
+        pinus.app.rpc.systimer.systimerRemote.setLadderCountDown.broadcast(rec.battleCode, rec.checkTime, LADDER_STATUS.CHECK);
+
+        return resResult(STATUS.SUCCESS, {
+            time: rec.checkTime + LADDER_CHECK_STOP_TIME,
+            battleCode: rec.battleCode
+        });
+    }
+
+    // 4. 出战撤退
+    async giveupCheck(msg: { battleCode: string }, session: BackendSession) {
+        let roleId = session.get('roleId');
+        let { battleCode } = msg;
+        // 更新ladderMatchRec
+        let rec = await LadderMatchRecModel.giveup(battleCode);
+        if(rec) {
+            pinus.app.rpc.systimer.systimerRemote.cancelLadderCountDown.broadcast(rec.battleCode);
+        }
+
+        return resResult(STATUS.SUCCESS, { status: 0, time: 0 });
+    }
+
+    // 5. 获取对手具体战场数据
+    async getOppData(msg: { battleCode: string }, session: BackendSession) {
+        let roleId = session.get('roleId');
+        let { battleCode } = msg;
+
+        // 判断是机器人还是真人
+
+        // 真人根据ladderMatch的defense，和warId对应的出兵表生成heroes
+
+        return resResult(STATUS.SUCCESS);
+    }
+
+    // 6. 布完阵开始挑战
+    async checkBattle(msg: { battleCode: string, heroes: { actorId: number, order: number }[] }, session: BackendSession) {
+        let roleId = session.get('roleId');
+        let { battleCode, heroes } = msg;
+
+        // 检查挑战次数
+        // 取消 chooseOpp 的倒计时
+        // 更新ladderMatchRec状态，记录下出阵时候玩家选择的顺序
+        // 开始倒计时，当时间到了还没battleEnd的时候算失败并发通知
+
+        return resResult(STATUS.SUCCESS)
+    }
+
+    // 7. 挑战结算
+    async battleEnd(msg: { battleCode: string, isSuccess: boolean }, session: BackendSession) {
+        let roleId = session.get('roleId');
+        let { battleCode, isSuccess } = msg;
+
+        // 取消 checkBattle 的倒计时
+
+        // 交换双方排名， transaction
+        // 更新redis
+
+        // 更新ladderMatchRec状态，并记录信息
+
+        // 刷新双方的对手并发通知
+        // 扣挑战次数
+        // 获取奖励
+
+        return resResult(STATUS.SUCCESS)
+    }
+
+    // 8. 战5次（扫荡）
+    async battleSweep(msg: { roleId: string, rank: number, count: number }, session: BackendSession) {
+        let roleId = session.get('roleId');
+        let { roleId: targetRoleId, rank, count } = msg;
+
+        // 检查是否可以扫荡对手
+        // 扣挑战次数
+        // 获取奖励
+
+        return resResult(STATUS.SUCCESS)
+    }
+
+    // 9. 设置防守阵容
    async saveDefense(msg: { warId: number, heroes: { actorId: number, ai: number, dataId: number, order: number }[] }, session: BackendSession) {
        let { warId, heroes } = msg;
        let roleId = session.get('roleId');
@@ -55,6 +180,30 @@ export class LadderHandler {
        return resResult(STATUS.SUCCESS, pick(result, 'defense'));
    }

+    // 10. 刷新对手
+    async refreshOppPlayers(msg: {}, session: BackendSession) {
+        let roleId = session.get('roleId');
+        let sid = session.get('sid');
+
+        let ladderData = await LadderMatchModel.findByRoleId(roleId);
+        if(!ladderData) return resResult(STATUS.LADDER_NOT_OPEN);
+
+        let update: LadderUpdateInter = {};
+        // 刷新次数
+        let refOppObj = refreshLadderDaily(ladderData);
+        if(refOppObj.shouldRefOpp) {
+            update = { ...refOppObj };
+        }
+
+        if(refOppObj.refOppCnt + 1 > LADDER.LADDER_REFRESH_TIMES) {
+            return resResult(STATUS.LADDER_REFRESH_CNT_MAX);
+        }
+        update.refOppCnt = refOppObj.refOppCnt + 1;
+        let oppPlayers = await refreshLadderEnemies(ladderData, update);
+
+        // 返回
+        return resResult(STATUS.SUCCESS, { refOppCnt: update.refOppCnt, oppPlayers });
+    }

    // 11. 购买次数
    async buyCnt(msg: { count: number }, session: BackendSession) {
@@ -86,6 +235,6 @@ export class LadderHandler {
        // 返回
        let result = new LadderDataReturn();
        result.setLadderData(ladderData);
-        return resResult(STATUS.SUCCESS, pick(result, 'buyCnt', 'challengeCnt'));
+        return resResult(STATUS.SUCCESS, pick(result, ['buyCnt', 'challengeCnt']));
    }
 }
--- a/game-server/app/servers/systimer/remote/systimerRemote.ts
+++ b/game-server/app/servers/systimer/remote/systimerRemote.ts
@@ -1,5 +1,5 @@
 import { Application, ChannelService } from 'pinus';
-import { resetPvpSeasonTime, guildActivityStart, gateActivityEnd, cityActivityEnd, raceActivityEnd, guildActivitySchedule, auctionSchedule, initMaintenance, stopMaintenance, initAutoCreateServer, addMailsToSchedule, updateTimeLimitRank } from '../../../services/timeTaskService';
+import { resetPvpSeasonTime, guildActivityStart, gateActivityEnd, cityActivityEnd, raceActivityEnd, guildActivitySchedule, auctionSchedule, initMaintenance, stopMaintenance, initAutoCreateServer, addMailsToSchedule, updateTimeLimitRank, setLadderCountDown, cancelLadderCountDown } from '../../../services/timeTaskService';
 import PvpDefenseType from '../../../db/PvpDefense';
 import { DicGuildActivity } from '../../../pubUtils/dictionary/DicGuildActivity';
 import { reloadResources } from '../../../pubUtils/data';
@@ -15,6 +15,7 @@ import { MailType } from '../../../db/Mail';
 import { GroupMailType } from '../../../db/GroupMail';
 import { ServerMailType } from '../../../db/ServerMail';
 import { ActivityModelType } from '../../../db/Activity';
+import { LADDER_STATUS } from '../../../consts';

 export default function (app: Application) {
    return new SystimerRemote(app);
@@ -198,4 +199,20 @@ export class SystimerRemote {
            errlogger.error(`remote ${__filename} \n ${e.stack}`);
        }
    }
+
+    public async setLadderCountDown(battleCode: string, time: number, status: LADDER_STATUS) {
+        try {
+            await setLadderCountDown(battleCode, time, status);
+        } catch(e) {
+            errlogger.error(`remote ${__filename} \n ${e.stack}`);
+        }
+    }
+
+    public async cancelLadderCountDown(battleCode: string) {
+        try {
+            await cancelLadderCountDown(battleCode);
+        } catch(e) {
+            errlogger.error(`remote ${__filename} \n ${e.stack}`);
+        }
+    }
 }
--- a/game-server/app/services/ladderService.ts
+++ b/game-server/app/services/ladderService.ts
@@ -1,12 +1,14 @@
-import { REDIS_KEY } from "../consts";
-import { LadderMatchModel, LadderMatchType } from "../db/LadderMatch";
+import { LADDER_OPP_STATUS, LADDER_STATUS, PUSH_ROUTE, REDIS_KEY } from "../consts";
+import { HeroType } from "../db/Hero";
+import { LadderMatchModel, LadderMatchType, LadderUpdateInter } from "../db/LadderMatch";
 import { LadderMatchRecModel } from "../db/LadderMatchRec";
-import { RoleModel } from "../db/Role";
-import { LadderDataReturn, LadderOppPlayerInDB, LadderOppPlayerReturn } from "../domain/battleField/ladder";
+import { RoleModel, RoleType } from "../db/Role";
+import { LadderDataReturn, LadderDefense, LadderOppPlayerHeroInfo, LadderOppPlayerInDB, LadderOppPlayerInfo, LadderOppPlayerReturn } from "../domain/battleField/ladder";
 import { RoleRankInfo } from "../domain/rank";
 import { gameData, getDicLadderMatchByMyRank } from "../pubUtils/data";
 import { ItemInter } from "../pubUtils/interface";
 import { getRandValueByMinMax, shouldRefresh } from "../pubUtils/util";
+import { sendMessageToUserWithSuc } from "./pushService";
 import { Rank } from "./rankService";
 import { combineItems } from "./role/util";

@@ -93,7 +95,7 @@ export async function getLadderMatchByRank(serverId: number, from: number, to: n
    return rawResults.map(cur => ({ rank: cur.scores[0], roleId: cur.field }))
 }

-export async function refreshLadderEnemies(ladderData: LadderMatchType) {
+export async function refreshLadderEnemies(ladderData: LadderMatchType, update: LadderUpdateInter = {}) {
    let rankNumbers = randOppRankNumbers(ladderData.rank); // 随机出想要的排名

    let min = rankNumbers[0], max = rankNumbers[rankNumbers.length - 1];
@@ -105,7 +107,7 @@ export async function refreshLadderEnemies(ladderData: LadderMatchType) {
        oppPlayersSave.push({ rank, roleId: player.roleId, isRobot: player.isRobot });
        oppPlayers.push(player);
    }
-    await LadderMatchModel.updateByRoleId(ladderData.roleId, { oppPlayers: oppPlayersSave });
+    await LadderMatchModel.updateByRoleId(ladderData.roleId, { ...update, oppPlayers: oppPlayersSave });
    return oppPlayers
 }

@@ -170,4 +172,94 @@ function isOver(isBefore: boolean, myRank: number, range: number, result: number
        console.log('after', myRank + range > result)
        return result > myRank + range;
    }
-}
+}
+
+export function checkRank(myRank: number, targetRank: number) {
+    let dicLadderMatch = getDicLadderMatchByMyRank(myRank);
+    if(!dicLadderMatch && myRank != 0 && targetRank != 3001) return false;
+    if(myRank < targetRank) { // 向后打
+        if(myRank + dicLadderMatch.rangeAfterMax < targetRank) return false;
+    } else { // 向前打
+        if(myRank - dicLadderMatch.rangeBeforeMax > targetRank) return false;
+    }
+    return true;
+}
+
+export async function getLadderOppStatus(ladderData: LadderMatchType, targetRoleId: string, myRank: number, rank: number) {
+    if(ladderData.rank != myRank) return { status: LADDER_OPP_STATUS.MY_RANK_CHANGE };
+    let { oppPlayers } = ladderData;
+    let curOppPlayer = oppPlayers.find(cur => cur.roleId == targetRoleId);
+    if(!curOppPlayer|| curOppPlayer.rank != rank) return { status: LADDER_OPP_STATUS.OPP_RANK_CHANGE };
+
+    if(curOppPlayer.isRobot) {
+        let hisLadderData = await LadderMatchModel.checkByRank(rank);
+        if(hisLadderData) return { status: LADDER_OPP_STATUS.OPP_RANK_CHANGE };
+
+        return { status: LADDER_OPP_STATUS.BATTLE, isRobot: true };
+    } else {
+        let hisLadderData = await LadderMatchModel.lock(targetRoleId, rank);
+        if(!hisLadderData) return { status: LADDER_OPP_STATUS.OPP_IS_LOCKED };
+
+        return { status: LADDER_OPP_STATUS.BATTLE, isRobot: false, hisLadderData };
+    }
+}
+
+/**
+ * 
+ * @param isRobot 是否是机器
+ * @param isDefense 是攻还是守方
+ * @param rank 排名
+ * @param ladderData 需要populate过的ladderMatch表
+ * @returns 
+ */
+export function generateInitRecInfo(isRobot: boolean, isDefense: boolean, rank: number, ladderData: LadderMatchType) {
+    if(isRobot) {
+        let dicLadderDifficultRatio = gameData.ladderDifficultRatio.get(rank);
+        let dicWarJson = gameData.warJson.get(dicLadderDifficultRatio.gkId)||[];
+
+        let heroes: LadderOppPlayerHeroInfo[] = [];
+        for(let json of dicWarJson) {
+            if(json.relation == 2) {
+                let hero = new LadderOppPlayerHeroInfo();
+                hero.setByWarJson(json);
+                heroes.push(hero);
+            }
+        }
+        let info = new LadderOppPlayerInfo();
+        info.initByRobot(dicLadderDifficultRatio, heroes, isDefense);
+        return info;
+    } else {
+        let defCe = calculateDefCeByDefense(ladderData.defense);
+        let role = <RoleType>ladderData.role;
+        let heroes: LadderOppPlayerHeroInfo[] = [];
+        if(isDefense) { // 防守方可以将武将也存入，攻方要等出战
+            let defenseHeroes = ladderData.defense?.heroes||[];
+            for(let defenseHero of defenseHeroes) {
+                let hero = new LadderOppPlayerHeroInfo();
+                hero.setByDefenseHero(<HeroType>defenseHero.hero);
+                heroes.push(hero);
+            }
+        }
+        let info = new LadderOppPlayerInfo();
+        info.initByPlayer(rank, role, heroes, defCe, isDefense);
+        return info;
+    }
+} 
+
+function calculateDefCeByDefense(defense: LadderDefense) {
+    if(!defense) return 0;
+    let ce = 0;
+    for(let hero of defense.heroes) {
+        ce += hero.ce;
+    }
+    return ce;
+}
+
+export async function ladderTimeout(battleCode: string, status: LADDER_STATUS) {
+    let rec = await LadderMatchRecModel.timeout(battleCode);
+    if(status == LADDER_STATUS.CHECK) {
+        await sendMessageToUserWithSuc(rec.roleId1, PUSH_ROUTE.LADDER_CHECK_STOP, { battleCode });
+    } else if (status == LADDER_STATUS.BATTLE) {
+        await sendMessageToUserWithSuc(rec.roleId1, PUSH_ROUTE.LADDER_BATTLE_STOP, { battleCode });
+    }
+}
--- a/game-server/app/services/timeTaskService.ts
+++ b/game-server/app/services/timeTaskService.ts
@@ -5,7 +5,7 @@ import { nowSeconds, getTimeFun, getSeconds } from '../pubUtils/timeUtil';
 import { getTodayGuildActivity, gameData } from '../pubUtils/data';
 import { pvpSeasonEnd } from './pvpService';
 import { getAllOnlineRoles, getAllServers, delGuildActivityRank, getServerCreateTime } from './redisService';
-import { GUILD_ACTIVITY_TYPE, REFRESH_TIME, COUNTER, AUCTION_TIME, GM_MAIL_TYPE, SERVER_TIMER, ACTIVITY_TYPE, PUSH_ROUTE, STATUS } from '../consts';
+import { GUILD_ACTIVITY_TYPE, REFRESH_TIME, COUNTER, AUCTION_TIME, GM_MAIL_TYPE, SERVER_TIMER, ACTIVITY_TYPE, PUSH_ROUTE, STATUS, LADDER_STATUS, LADDER_CHECK_STOP_TIME, LADDER_BATTLE_STOP_TIME, LADDER_SERVER_GAP_TIME } from '../consts';
 import { pinus } from 'pinus';
 import { settleGuildWeekly } from './guildService';
 import { SendMailFun, sendMailsByGmMail, } from './mailService';
@@ -39,6 +39,7 @@ import { resResult } from '../pubUtils/util';
 import { checkPopUpConditionWhenGuildActivityEnd } from './activity/popUpShopService';
 import { pushRefreshTime } from './connectorService';
 import { sendUnReceivedActivityDailyCoin } from './activity/dailyCoinService';
+import { ladderTimeout } from './ladderService';

 const PER_SECOND = 1 * 1000;
 const PER_DAY = 24 * 60 * 60;
@@ -734,4 +735,20 @@ async function setTakeRankSnapshotSchedule(activityId: number, serverId: number,
        await takeSnapshot(data, serverId);
    })
 }
-// —————————————— 活动 end —————————————— //
+// —————————————— 活动 end —————————————— //
+
+// —————————————— 名将擂台 start —————————————— //
+export async function setLadderCountDown(battleCode: string, time: number, status: LADDER_STATUS) {
+    let endTime = time + (status == LADDER_STATUS.CHECK? LADDER_CHECK_STOP_TIME: LADDER_BATTLE_STOP_TIME) + LADDER_SERVER_GAP_TIME;
+    scheduleJob(`ladder${battleCode}`, endTime * 1000, async () => {
+        await ladderTimeout(battleCode, status);
+    })
+}
+
+export async function cancelLadderCountDown(battleCode: string) {
+    if(scheduledJobs[`ladder${battleCode}`]) {
+        scheduledJobs[`ladder${battleCode}`].cancel();
+    }
+}
+
+// —————————————— 名将擂台 end —————————————— //