✨ feat(gvg): 征战中原锁定对手

2023-02-17 10:58:06 +08:00
parent 4035645772
commit b727249106
12 changed files with 635 additions and 36 deletions
@@ -1,12 +1,17 @@
 import { Application, BackendSession, ChannelService, HandlerService } from "pinus";
-import { GVG_PERIOD, STATUS } from "../../../consts";
+import { GVG_ITEM, GVG_PERIOD, ITEM_CHANGE_REASON, STATUS, VESTIGE_OPP_STATUS } from "../../../consts";
+import { GVGLeagueModel } from "../../../db/GVGLeague";
+import { GVGUserItemModel } from "../../../db/GVGUserItem";
+import { GVGVestigeLockModel } from "../../../db/GVGVestigeLock";
 import { GVGVestigeRankModel } from "../../../db/GVGVestigeRank";
+import { GVGVestigeRecModel } from "../../../db/GVGVestigeRec";
 import { HeroModel } from "../../../db/Hero";
 import { RoleModel } from "../../../db/Role";
 import { GVGVestigeOppLineup } from "../../../domain/gvgField/returnData";
 import { gameData } from "../../../pubUtils/data";
 import { resResult } from "../../../pubUtils/util";
-import { checkVestige, getOppPlayerByRanks, refreshVestigeOppRanks } from "../../../services/gvg/gvgFightService";
+import { checkVestige, checkVestigeOppStatus, checkVestigeRank, generateAttackInfo, generateDefenseInfo, getOppDetailData, getOppPlayerByRanks, getVestigeUsedHeroes, isRobot, refreshVestigeOppRanks } from "../../../services/gvg/gvgFightService";
+import { addGVGReward, handleGVGCost } from "../../../services/gvg/gvgItemService";
 import { getGroupIdOfServer, getGVGPeriodData } from "../../../services/gvg/gvgService";
 import { getAllServerName } from "../../../services/redisService";

@@ -42,7 +47,7 @@ export class GVGProduceHandler {
        let dicRankMap = gameData.gvgVestige.get(vestigeId);
        if(!dicRankMap) return resResult(STATUS.DIC_DATA_NOT_FOUND);

-        let myVestigateRank = await GVGVestigeRankModel.findRankByRole(vestigeId, roleId); // 我在这个遗迹的排名
+        let myVestigateRank = await GVGVestigeRankModel.findByRole(vestigeId, roleId); // 我在这个遗迹的排名
        if(!myVestigateRank) {
            let role = await RoleModel.findByRoleId(roleId, 'roleId');
            let oppRanks = refreshVestigeOppRanks(-1);
@@ -53,6 +58,7 @@ export class GVGProduceHandler {

        let lineupCe = lineup.reduce((pre, cur) => pre + cur.ce, 0);
        let oppPlayers = await getOppPlayerByRanks(serverId, groupId, vestigeId, oppRanks);
+        let usedHeroes = await getVestigeUsedHeroes(roleId, vestigeId);

        return resResult(STATUS.SUCCESS, {
            vestigeId,
@@ -60,7 +66,8 @@ export class GVGProduceHandler {
            score,
            lineup, lineupCe,
            oppPlayers,
-            refreshCnt
+            refreshCnt,
+            usedHeroes
        })
    }

@@ -75,7 +82,7 @@ export class GVGProduceHandler {
        const serverId: number = session.get('serverId');

        let { vestigeId, roleId: targetRoleId, rank } = msg;
-        let myVestigateRank = await GVGVestigeRankModel.findRankByRole(vestigeId, roleId); // 我在这个遗迹的排名
+        let myVestigateRank = await GVGVestigeRankModel.findByRole(vestigeId, roleId); // 我在这个遗迹的排名

        const serverNames = await getAllServerName();

@@ -90,7 +97,7 @@ export class GVGProduceHandler {
            let dicWarJson = gameData.warJson.get(dicWar.dispatchJsonId);
            result.setRobot(dicGVGVestige, dicWarJson, serverNames[serverId]);
        } else {
-            let hisVestigateRank = await GVGVestigeRankModel.findRankByRole(vestigeId, roleId); // 我在这个遗迹的排名
+            let hisVestigateRank = await GVGVestigeRankModel.findByRole(vestigeId, roleId);
            if(!hisVestigateRank) return resResult(STATUS.GVG_VESTIGE_TARGET_NOT_FOUND);

            let role = await RoleModel.findByRoleId(hisVestigateRank.roleId, 'roleId roleName serverId guildName title lv heads head spines spine frames frame')
@@ -109,8 +116,57 @@ export class GVGProduceHandler {
    }

    // 选择对手
-    async chooseOpp(msg: { vestigeId: number, rank: number, myRank: number }, session: BackendSession) {
+    async chooseOpp(msg: { vestigeId: number, roleId: string, rank: number, myRank: number }, session: BackendSession) {

+        let roleId = session.get('roleId');
+        let roleName = session.get('roleName');
+        let serverId = session.get('serverId');
+        let guildCode = session.get('guildCode');
+        let sid = session.get('sid');
+        let { vestigeId, roleId: targetRoleId, rank, myRank } = msg;
+
+        let { configId, period } = getGVGPeriodData();
+        if(period != GVG_PERIOD.PREPARE) return resResult(STATUS.GVG_NOT_PREPARE_PERIOD);
+
+        let dicRank = gameData.gvgVestige.get(vestigeId)?.get(rank);
+        if(!dicRank) return resResult(STATUS.DIC_DATA_NOT_FOUND);
+
+        let myLeague = await GVGLeagueModel.findLeagueByGuild(guildCode);
+        if(!myLeague) return resResult(STATUS.GVG_LEAGUE_NOT_EXIST);
+
+        // 检查对手排名/自己排名
+        if(!checkVestigeRank(myRank, rank)) return resResult(STATUS.GVG_VESTIGE_RANK_ERR);
+
+        const hasItem = await GVGUserItemModel.checkItemCnt(configId, myLeague.leagueCode, roleId, GVG_ITEM.FIGHT_COIN, 1);
+        if(!hasItem) return resResult(STATUS.GVG_ITEMS_NOT_ENOUGH);
+        let groupId = await getGroupIdOfServer(serverId);
+
+        let status = await checkVestigeOppStatus(configId, groupId, vestigeId, roleId, myRank, targetRoleId, rank); // 锁
+        if(status != VESTIGE_OPP_STATUS.BATTLE) {
+            let oppRanks = refreshVestigeOppRanks(myRank);
+            let oppPlayers = await getOppPlayerByRanks(serverId, groupId, vestigeId, oppRanks);
+            return resResult(STATUS.SUCCESS, { status, oppPlayers });
+        }
+
+        // 扣征战令
+        const costResult = await handleGVGCost(roleId, myLeague.leagueCode, sid, [{ id: GVG_ITEM.FIGHT_COIN, count: 1 }], [], ITEM_CHANGE_REASON.GVG_VESTIGE_START);
+        if(!costResult) {
+            await GVGVestigeLockModel.releaseLock(groupId, vestigeId, rank);
+            return resResult(STATUS.GVG_ITEMS_NOT_ENOUGH);
+        }
+        // 获取征战令对应奖励
+        const leagueGoods = await addGVGReward(roleId, roleName, myLeague.leagueCode, sid, dicRank.battleLeagueReward, dicRank.battleReward, ITEM_CHANGE_REASON.GVG_VESTIGE_START);
+        // 创建rec
+        const attackInfo = await generateAttackInfo(roleId, myRank);
+        const defenseInfo = await generateDefenseInfo(targetRoleId, vestigeId, rank);
+        const rec = await GVGVestigeRecModel.createRec(configId, vestigeId, groupId, attackInfo, defenseInfo, leagueGoods);
+        const oppDetail = await getOppDetailData(rec);
+
+        return resResult(STATUS.SUCCESS, {
+            battleCode: rec.battleCode,
+            time: rec.checkTime,
+            ...oppDetail
+        });
    }

    // 出战界面撤退
@@ -1,15 +1,20 @@
 // 征战中原相关

-import { GVG_PERIOD } from "../../consts";
+import { GVG_PERIOD, STATUS, VESTIGE_OPP_STATUS } from "../../consts";
+import { ArtifactModel } from "../../db/Artifact";
 import { GVGVestigeModel } from "../../db/GVGVestige";
-import { GVGVestigeRankModel } from "../../db/GVGVestigeRank";
+import { GVGVestigeLockModel } from "../../db/GVGVestigeLock";
+import { GVGVestigeRankModel, GVGVestigeRankType } from "../../db/GVGVestigeRank";
+import { GVGVestigeRecType } from "../../db/GVGVestigeRec";
 import { HeroModel } from "../../db/Hero";
-import { RoleType } from "../../db/Role";
+import { RoleModel, RoleType } from "../../db/Role";
+import { OppDetailData, OppDetailHeroData, OppPlayerHeroInfo, OppPlayerInfo } from "../../domain/gvgField/gvgDb";
 import { GVGVestigeOppPlayer } from "../../domain/gvgField/returnData";
 import { gameData, getGVGVestigeRange } from "../../pubUtils/data";
 import { getTimeFun } from "../../pubUtils/timeUtil";
-import { getRandEelm, getRandValueByMinMax } from "../../pubUtils/util";
+import { getRandEelm, getRandValueByMinMax, resResult } from "../../pubUtils/util";
 import { getNumberArr, uniqueArr } from "../ladderService";
+import { getHeroesAttributes } from "../playerCeService";
 import { calLineupScore } from "../pvpService";
 import { getAllServerName } from "../redisService";
 import { getGroupIdOfServer, getGVGServerType } from "./gvgService";
@@ -65,6 +70,7 @@ function randomRank(min: number, max: number, len: number) {
    return getRandEelm(arr, len);
 }

+// 根据ranks获取oppPlayer显示数据
 export async function getOppPlayerByRanks(serverId: number, groupId: number, vestigeId: number, ranks: number[]) {
    let serverNames = await getAllServerName();
    let opps = await GVGVestigeRankModel.findByRanks(groupId, vestigeId, ranks);
@@ -86,4 +92,123 @@ export async function getOppPlayerByRanks(serverId: number, groupId: number, ves
    }
    
    return result;
-}
+}
+
+// 获取其他遗迹里使用过的武将
+export async function getVestigeUsedHeroes(roleId: string, curVestigeId: number) {
+    let myDatas = await GVGVestigeRankModel.findAllByRole(roleId);
+    let result: number[] = [];
+    for(let { vestigeId, lineup = [] } of myDatas) {
+        if(vestigeId == curVestigeId) continue;
+        result.push(...lineup.map(cur => cur.actorId));
+    }
+    return result;
+}
+
+// 检查我的排名是否可以挑战对方的排名
+export function checkVestigeRank(myRank: number, targetRank: number) {
+    let dicRange = getGVGVestigeRange(myRank);
+    if(!dicRange) return false;
+    if(myRank == targetRank || targetRank == 0) return false;
+
+    // 是否可以挑战最前的几个排名
+    if(dicRange.topChallengeFrom <= targetRank && dicRange.topChallengeTo >= targetRank) return true;
+    if(dicRange.rangeBeforeTo == -1) {
+        if(dicRange.rangeBeforeFrom < targetRank && myRank > targetRank) return true;
+    } else {
+        if(dicRange.rangeBeforeFrom < targetRank && dicRange.rangeBeforeTo >= targetRank) return true;
+    }
+    if(dicRange.rangeAfterTo == -1) {
+        if(dicRange.rangeAfterFrom < targetRank && myRank > targetRank) return true;
+    } else {
+        if(dicRange.rangeAfterFrom < targetRank && dicRange.rangeAfterTo >= targetRank) return true;
+    }
+
+    return false;
+}
+
+export function isRobot(roleId: string) {
+    if(!roleId) roleId = '';
+    return roleId.startsWith('robot');
+}
+
+export async function checkVestigeOppStatus(configId: number, groupId: number, vestigeId: number, roleId: string, myRank: number, targetRoleId: string, rank: number) {
+    
+    let myData = await GVGVestigeRankModel.findByRole(vestigeId, roleId);
+    if(myData?.rank != myRank) return VESTIGE_OPP_STATUS.MY_RANK_CHANGE;
+
+    if(isRobot(targetRoleId)) {
+        let targetData = await GVGVestigeRankModel.findByRank(vestigeId, rank);
+        if(targetData) return VESTIGE_OPP_STATUS.OPP_RANK_CHANGE;
+    } else {
+        let targetData = await GVGVestigeRankModel.findByRole(vestigeId, targetRoleId);
+        if(targetData?.rank != rank) return VESTIGE_OPP_STATUS.OPP_RANK_CHANGE;
+    }
+    let lockResult = await GVGVestigeLockModel.chooseOppLock(groupId, vestigeId, rank, configId, roleId, targetRoleId);
+    if(!lockResult) return VESTIGE_OPP_STATUS.OPP_IS_LOCKED;
+
+    return VESTIGE_OPP_STATUS.BATTLE;
+}
+
+// 生成防守数据
+export async function generateDefenseInfo(roleId: string, vestigeId: number, rank: number) {
+    if(isRobot(roleId)) {
+        let dicRank = gameData.gvgVestige.get(vestigeId)?.get(rank); // 调用之前已经验证过了
+        let dicWar = gameData.war.get(dicRank?.warId);
+        let dicWarJson = gameData.warJson.get(dicWar?.dispatchJsonId);
+        if(!dicWarJson) return null;
+
+        let heroes: OppPlayerHeroInfo[] = [];
+        for(let json of dicWarJson) {
+            if(json.relation == 2) {
+                let hero = new OppPlayerHeroInfo();
+                hero.setByWarJson(json);
+                heroes.push(hero);
+            }
+        }
+        let info = new OppPlayerInfo();
+        info.initByRobot(dicRank, heroes, true);
+        return info;
+    } else {
+        let playerVestigeData = await GVGVestigeRankModel.findByRole(vestigeId, roleId);
+        if(!playerVestigeData) return null;
+        let lineup = playerVestigeData.lineup||[];
+        let hids = lineup.map(cur => cur.actorId);
+        let role = await RoleModel.findByRoleId(playerVestigeData.roleId, 'roleId roleName heads head frames frame spines spine title lv');
+        let heroes = await HeroModel.findByHidRange(hids, playerVestigeData.roleId, 'hid skinId lv star colorStar quality');
+
+        let info = new OppPlayerInfo();
+        info.initByPlayer(playerVestigeData.rank, role, heroes, lineup, true);
+        return info;
+    }
+}
+
+export async function generateAttackInfo(roleId: string, rank: number) {
+    let role = await RoleModel.findByRoleId(roleId, 'roleId roleName heads head frames frame spines spine title lv');
+    let info = new OppPlayerInfo();
+    info.initByPlayer(rank, role, [], [], false);
+    return info;
+}
+
+export async function getOppDetailData(rec: GVGVestigeRecType) {
+    let isRobot = rec.defenseInfo.isRobot;
+    let dicLadderDifficultRatio = gameData.ladderDifficultRatio.get(rec.defenseInfo.oldRank);
+    let result = new OppDetailData();
+    if(!isRobot) {
+        const dicWar = gameData.war.get(dicLadderDifficultRatio.gkId);
+        const dicWarJson = gameData.warJson.get(dicWar.dispatchJsonId);
+        const defenseInfo = rec.defenseInfo.heroes||[];
+        const hids = defenseInfo.map(cur => cur.hid);
+        const heroes = await HeroModel.findByHidRange(hids, rec.defenseRoleId, 'hid lv quality star colorStar');
+        const artifactSeids = heroes.map(hero => hero.artifact);
+        const artifacts = await ArtifactModel.findbySeqIds(rec.defenseRoleId, artifactSeids);
+        result.setByPlayer(dicWarJson, defenseInfo, heroes, artifacts);
+        let attrByHid = await getHeroesAttributes(rec.defenseRoleId);
+        for(let [hid, attribute] of attrByHid) {
+            result.setAttribute(hid, attribute.getAttributesToString());
+        }
+    }
+
+    return result;
+
+}