名将擂台：基础界面

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

@@ -0,0 +1,91 @@
+
+import { Application, BackendSession, pinus, HandlerService, } from 'pinus';
+import { uniq, findWhere, findIndex, pick } from 'underscore';
+import { gameData, 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 { 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';
+
+export default function (app: Application) {
+    new HandlerService(app, {});
+    return new LadderHandler(app);
+}
+
+export class LadderHandler {
+    constructor(private app: Application) {
+    }
+
+    //1获取主界面
+    async getData(msg: {}, session: BackendSession) {
+        let roleId = session.get('roleId');
+ 
+        let result = await getLadderData(roleId, true)
+        return resResult(STATUS.SUCCESS, result);
+    }
+
+    // 8. 设置防守阵容
+    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');
+
+        let ladderData = await LadderMatchModel.findByRoleId(roleId);
+        if(!ladderData) return resResult(STATUS.LADDER_NOT_OPEN);
+
+        let hids: number[] = heroes.map(cur => cur.actorId);
+        let dbHeroes = await HeroModel.findByHidRange(hids, roleId, '_id hid ce', true);
+
+        let defenseHeroes = heroes.map(cur => {
+            let dbHero = dbHeroes.find(ccur => ccur.hid == cur.actorId);
+            return dbHero && new LadderDefenseHero(cur, dbHero._id, dbHero.ce);
+        }).filter(cur => cur);
+        let defense = new LadderDefense(defenseHeroes, warId);
+        ladderData = await LadderMatchModel.updateByRoleId(roleId, { defense });
+        // 返回
+        let result = new LadderDataReturn();
+        result.setLadderData(ladderData);
+
+        return resResult(STATUS.SUCCESS, pick(result, 'defense'));
+    }
+
+
+    // 11. 购买次数
+    async buyCnt(msg: { count: number }, session: BackendSession) {
+        let { count } = msg;
+        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.buyCnt + count > LADDER.LADDER_CHALLENGE_COST_TIMES) {
+            return resResult(STATUS.LADDER_BUY_MAX);
+        }
+        let consumes = getBuyCntCost(refOppObj.buyCnt, count);
+        if(!consumes) return resResult(STATUS.LADDER_BUY_MAX);
+
+        let consumeResult = await handleCost(roleId, sid, consumes||[], ITEM_CHANGE_REASON.LADDER_BUY_CNT);
+        if(!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
+
+        update.buyCnt = refOppObj.buyCnt + count;
+        ladderData = await LadderMatchModel.updateByRoleId(roleId, update);
+        // 返回
+        let result = new LadderDataReturn();
+        result.setLadderData(ladderData);
+        return resResult(STATUS.SUCCESS, pick(result, 'buyCnt', 'challengeCnt'));
+    }
+}

game-server/app/services/connectorService.ts

@@ -46,6 +46,7 @@ import { sendMessageToAllWithSuc, sendMessageToServerWithSuc, sendMessageToUser,
 import { getSurvey } from './gmService';
 import { ComBattleTeamModel } from '../db/ComBattleTeam';
 import { INFO_WINDOW } from '../pubUtils/dicParam';
+import { getLadderData } from './ladderService';
 
 /**
  * init: 初始的时候是否推送 true-推 false-不推
@@ -79,6 +80,7 @@ const modules = [
     { id: 24, type: 'donate', init: false, refresh: true, guild: true },
     { id: 25, type: 'shop', init: false, refresh: true, guild: false },
     { id: 26, type: 'survey', init: false, refresh: true, guild: false },
+    { id: 27, type: 'ladder', init: false, refresh: true, guild: false },
 ]
 
 export async function pushData(hasInit: boolean, role: RoleType, session: FrontendOrBackendSession, pushType: 'entry' | 'refresh' = 'entry') {
@@ -206,6 +208,8 @@ export async function getModuleData(type: string, data: { role: RoleType, sessio
                 return getMainChapter(role);
             case 'survey':
                 return await getSurvey(role.roleId, role.lv);
+            case 'ladder':
+                return await getLadderData(role.roleId, false);
             default:
                 return null;
         }

game-server/app/services/ladderService.ts

@@ -0,0 +1,66 @@
+import { LadderMatchModel, LadderMatchType } from "../db/LadderMatch";
+import { LadderMatchRecModel } from "../db/LadderMatchRec";
+import { RoleModel } from "../db/Role";
+import { LadderDataReturn } from "../domain/battleField/ladder";
+import { gameData } from "../pubUtils/data";
+import { ItemInter } from "../pubUtils/interface";
+import { shouldRefresh } from "../pubUtils/util";
+import { combineItems } from "./role/util";
+
+export function refreshLadderDaily(ladderData: LadderMatchType) {
+
+    let { refOppCnt = 0, buyCnt = 0, challengeCnt = 0, refDaily } = ladderData;
+    let curTime = new Date();
+    let shouldRefOpp = shouldRefresh(refDaily, curTime);
+    if (shouldRefOpp) {
+        refOppCnt = 0; buyCnt = 0; challengeCnt =0; refDaily = curTime;
+    }
+    return {
+        shouldRefOpp,
+        refOppCnt, refDaily, buyCnt, challengeCnt,
+    }
+}
+
+export function getBuyCntCost(buyCnt: number, incCnt: number) {
+    let items: ItemInter[] = [];
+    for(let i = 1; i <= incCnt; i++) {
+        let cost = getSingleBuyCost(buyCnt + i);
+        if(!cost) return false;
+        items.push(cost);
+    }
+    return combineItems(items);
+}
+
+function getSingleBuyCost(buyCnt: number) {
+    for(let { id, count, times } of gameData.ladderConsume) {
+        if(buyCnt <= times) {
+            return { id, count }
+        }
+    }
+    return false
+}
+
+export async function getLadderData(roleId: string, needOppPlayer: boolean) {
+    let ladderData = await LadderMatchModel.findByRoleId(roleId);
+    if(!ladderData) {
+        let role = await RoleModel.findByRoleId(roleId);
+        ladderData = await LadderMatchModel.createLadder({ serverId: role.serverId, roleId: role.roleId, role: role._id });
+    }
+
+    // 刷新次数
+    let refOppObj = refreshLadderDaily(ladderData);
+    if(refOppObj.shouldRefOpp) {
+        ladderData = await LadderMatchModel.updateByRoleId(roleId, refOppObj);
+    }
+
+    let ladderRec = await LadderMatchRecModel.findNotCompleteRecByRoleId(roleId);
+
+    let result = new LadderDataReturn();
+    result.setLadderData(ladderData, ladderRec);
+
+    if(needOppPlayer) {
+        // let oppPlayersReturn = await getEnemies(ladderData.oppPlayers||[], ladderData.winStreakNum);
+        // result.setOppPlayers(oppPlayersReturn);
+    }
+    return result;
+}