镇念塔：一键跳关

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

@@ -1,5 +1,5 @@
 import { STATUS } from './../../../consts/statusCode';
-import { HANG_UP_CONSTS, ITEM_CHANGE_REASON, REDIS_KEY } from './../../../consts';
+import { HANG_UP_CONSTS, ITEM_CHANGE_REASON, MSG_SOURCE, REDIS_KEY } from './../../../consts';
 import { TaskHero, TowerTaskRecModel, TowerTaskRecType } from './../../../db/TowerTaskRec';
 import { HangUpSpdUpRecModel } from './../../../db/HangUpSpdUpRec';
 import { HangUpRecordModel } from './../../../db/HangUpRecord';
@@ -7,13 +7,16 @@ import { RoleModel } from './../../../db/Role';
 import { TowerRecordModel } from './../../../db/TowerRecord';
 import { Application, BackendSession } from 'pinus';
 import { resResult, genCode, shouldRefresh } from '../../../pubUtils/util';
-import { calcuHangUpReward, refreshTasks, treatTask, getRemainTime, getTowerStatus, getHungupRewards, getTasks, checkTaskRewards, getTowerTaskCostGold, getHangSpdUpCostGold, getManyHangSpdUpCostGold, getTaskStatus } from '../../../services/battleService';
+import { calcuHangUpReward, refreshTasks, treatTask, getRemainTime, getTowerStatus, getHungupRewards, getTasks, checkTaskRewards, getTowerTaskCostGold, getHangSpdUpCostGold, getManyHangSpdUpCostGold, getTaskStatus, checkForbiddenChar, checkAndStartHungUp, createNewTowerRecord, getTowerRecByLv } from '../../../services/battleService';
 import { addItems, handleCost } from '../../../services/rewardService';
 import { checkBattleHeroes } from '../../../services/normalBattleService';
 import { getGoldObject } from '../../../pubUtils/itemUtils';
 import { gameData } from '../../../pubUtils/data';
 import * as dicParam from '../../../pubUtils/dicParam';
 import { isNumber } from 'underscore';
+import { HeroModel } from '../../../db/Hero';
+import { vipCanSkipTower } from '../../../services/activity/monthlyTicketService';
+import { pushTowerMsg } from '../../../services/sysChatService';
 
 export default function(app: Application) {
     return new TowerBattleHandler(app);
@@ -54,6 +57,12 @@ export class TowerBattleHandler {
         return resResult(STATUS.SUCCESS, record);
     }
 
+    /**
+     * 查询当前挂机可得奖励
+     * @param msg 
+     * @param session 
+     * @returns 
+     */
     async checkHangUpRewards(msg: {}, session: BackendSession) {
         let roleId = session.get('roleId');
         let result = await getHungupRewards(roleId);
@@ -63,6 +72,12 @@ export class TowerBattleHandler {
         return resResult(STATUS.SUCCESS, result);
     }
 
+    /**
+     * 领取当前挂机可得奖励
+     * @param msg 
+     * @param session 
+     * @returns 
+     */
     async recHangUpRewards(msg: {}, session: BackendSession) {
         let roleId = session.get('roleId');
         let roleName = session.get('roleName');
@@ -81,6 +96,12 @@ export class TowerBattleHandler {
         return resResult(STATUS.SUCCESS, { endTime, hangUpPassTime: Math.floor((deltaTime%HANG_UP_CONSTS.UNIT_TIME)/1000), goods });
     }
 
+    /**
+     * 加速挂机
+     * @param {{speedUpCnt: number}} msg 加速次数
+     * @param session 
+     * @returns 
+     */
     async hangUpSpeedUp(msg: {speedUpCnt: number}, session: BackendSession) {
         let roleId = session.get('roleId');
         let roleName = session.get('roleName');
@@ -256,4 +277,55 @@ export class TowerBattleHandler {
         let costGold = getTowerTaskCostGold(role.towerTaskReCnt, role.towerTaskRefTime);
         return resResult(STATUS.SUCCESS, { curTasks: treatTask(curTasks, curTime), goods, refRemainTime, nextCostGold: costGold });
     }
+
+    async skipTower(msg: { }, session: BackendSession) {
+        let roleId = session.get('roleId');
+        let roleName = session.get('roleName');
+        let serverId = session.get('serverId');
+        let sid = session.get('sid');
+
+        let role = await RoleModel.findByRoleId(roleId);
+        let dicTower = gameData.tower.get(role.towerLv);
+        if(!dicTower.canSkip) {
+            return resResult(STATUS.TOWER_CANNOT_SKIP);
+        }
+
+        let { warStatus, heroes: recHeroes } = await getTowerRecByLv(roleId, role.towerLv);
+
+        // 检查战力是否足够
+        let heroes = await HeroModel.findByRole(roleId, [{ field: 'ce', sortBy: -1 }], 'hid ce', true);
+        let recommendCeSum = 0, heroesCeSum = 0;
+        for(let { warId, status } of warStatus) {
+            if(!status) {
+                let dicWar = gameData.war.get(warId);
+                recommendCeSum += dicWar.recommendedPower;
+                let heroNum = 0;
+                for(let hero of heroes) {
+                    if(recHeroes.indexOf(hero.hid) == -1 && !checkForbiddenChar(hero.hid, dicWar.fobiddenCharactor)) {
+                        heroNum++;
+                        recHeroes.push(hero.hid);
+                        heroesCeSum += hero.ce;
+                    }
+                    if(heroNum >= dicWar.minHeroNum) break;
+                }
+            }
+        }
+        if(!vipCanSkipTower(recommendCeSum, heroesCeSum, role.vipStartTime)) {
+            return resResult(STATUS.TOWER_SKIP_POWER_NOT_ENOUGH)
+        }
+
+        // 更新玩家表
+        role = await RoleModel.towerLvUp(roleId);
+        // 更新towerRecord
+        await TowerRecordModel.skipTower(roleId, role.towerLv - 1, recHeroes);
+        await createNewTowerRecord(roleId, role.towerLv);
+        await checkAndStartHungUp(roleId, roleName, role.towerLv);
+
+        let goods = await addItems(roleId, roleName, sid, dicTower.reward, ITEM_CHANGE_REASON.TOWER_BATTLE_END);
+        pushTowerMsg(roleId, roleName, serverId, MSG_SOURCE.TOWER_SUC, role.lv);
+
+        let data = await getTowerStatus(role);
+
+        return resResult(STATUS.SUCCESS, { ...data, goods });
+    }
 }

game-server/app/services/activity/activityService.ts

@@ -38,6 +38,7 @@ import { ActivityTaskPointModel } from '../../db/ActivityTaskPoint';
 import { getRoleOnlineInfo } from '../redisService';
 import { addTaskPassPoint } from './taskPassService';
 import { getGuildChannelSid } from '../chatService';
+import { getGuildPayDataShow } from './guildPayService';
 
 /**
    * 获取活动数据
@@ -203,7 +204,7 @@ export async function getActivity(serverId: number, roleId: string, guildCode: s
             }
         case ACTIVITY_TYPE.GUILD_PAY:
             {
-
+                activityData = await getGuildPayDataShow(serverId, activityId, roleId, guildCode);
             }
         default: {
             console.log('未知活动类型.........', activityType)

game-server/app/services/activity/monthlyTicketService.ts

@@ -214,4 +214,11 @@ export function getVipRegretCnt(vipStartTime: number) {
         count = VIP.VIP_REGRET_CNT_WITH_VIP;
     }
     return count;
+}
+
+export function vipCanSkipTower(recommendCeSum: number, heroesCeSum: number, vipStartTime: number) {
+    console.log('####', recommendCeSum, heroesCeSum, vipStartTime, );
+    let ratio = vipStartTime > 0? VIP.VIP_TOWER_SKIP_CE_RATIO_WITH_VIP: VIP.VIP_TOWER_SKIP_CE_RATIO_WITHOUT_VIP;
+    console.log('#####', VIP.VIP_TOWER_SKIP_CE_RATIO_WITH_VIP, VIP.VIP_TOWER_SKIP_CE_RATIO_WITHOUT_VIP, ratio)
+    return heroesCeSum > recommendCeSum * ratio;
 }

game-server/app/services/battleService.ts

@@ -29,6 +29,20 @@ export async function getTowerStatus(role: RoleType) {
         let role = await RoleModel.towerLvUp(roleId);
         towerLv = role.towerLv;
     }
+    let towerRec = await getTowerRecByLv(roleId, towerLv);
+
+    return {
+        canHungUp: canHunUp(towerLv),
+        canSendTask: towerLv - 1 >= dicParam.TOWER_SEARCH.TOWER_SEARCH_STARTLIMITED,
+        sendTaskEnableLv: dicParam.TOWER_SEARCH.TOWER_SEARCH_STARTLIMITED,
+        curLv: towerLv,
+        usedHeroes: towerRec.heroes,
+        progress: towerRec.warStatus
+    };
+}
+
+export async function getTowerRecByLv(roleId: string, towerLv: number) {
+
     let towerRec = await TowerRecordModel.getRecordByLv(roleId, towerLv);
     if (!towerRec) {
         const towerInfo = gameData.tower.get(towerLv);
@@ -39,15 +53,7 @@ export async function getTowerStatus(role: RoleType) {
         towerRec = await TowerRecordModel.createRecord({roleId, lv: towerLv, warStatus: sts});
         // return { code: 201, data: '天梯记录异常' };
     }
-    return {
+    return towerRec;
-        canHungUp: towerLv - 1 >= dicParam.TOWER_HANG_UP.TOWER_HANG_UP_ENABLE_LV,
-        hungUpEnableLv: dicParam.TOWER_HANG_UP.TOWER_HANG_UP_ENABLE_LV,
-        canSendTask: towerLv - 1 >= dicParam.TOWER_SEARCH.TOWER_SEARCH_STARTLIMITED,
-        sendTaskEnableLv: dicParam.TOWER_SEARCH.TOWER_SEARCH_STARTLIMITED,
-        curLv: towerLv,
-        usedHeroes: towerRec.heroes,
-        progress: towerRec.warStatus
-    };
 }
 
 /**
@@ -175,7 +181,7 @@ export async function checkTowerWar(roleId: string, battleId: number, seqIds: nu
     };
 }
 
-function checkForbiddenChar(hid: number, fobiddenCharactor: {type: number, id: number}[]) {
+export function checkForbiddenChar(hid: number, fobiddenCharactor: {type: number, id: number}[]) {
     let dicHero = gameData.hero.get(hid);
     let dicJob = gameData.job.get(dicHero.jobid);
     let flag = false;
@@ -226,21 +232,10 @@ export async function towerBattleEnd(sid: string, roleId: string, serverId: numb
             let r = new Rank(REDIS_KEY.TOWER_RANK, { serverId });
             await r.setRankWithRoleInfo(roleId, role.towerLv - 1, role.towerUpTime.getTime(), role);
 
-            const nextTowerInfo = gameData.tower.get(role.towerLv);
+            await createNewTowerRecord(roleId, role.towerLv);
-            if (nextTowerInfo) {
-                const { warArray } = nextTowerInfo;
-                const sts = warArray.map(id => {
-                    return { warId: id, status: false };
-                });
-
-                await TowerRecordModel.createRecord({ roleId, lv: role.towerLv, warStatus: sts });
-
-            }
             const { reward } = gameData.tower.get(role.towerLv - 1);
             if (reward) towerReward = reward;
-            if (role.towerLv == dicParam.TOWER_HANG_UP.TOWER_HANG_UP_ENABLE_LV + 1) {
+            await checkAndStartHungUp(roleId, roleName, role.towerLv - 1);
-                await startHangUp(roleId, roleName);
-            }
             // 任务
             await checkTask(roleId, sid, TASK_TYPE.BATTLE_TOWER_LV, role.towerLv - 1, false, {});
             await checkActivityTask(serverId, sid, roleId, TASK_TYPE.BATTLE_TOWER_LV, 1, { towerLv: role.towerLv - 1 });
@@ -256,13 +251,47 @@ export async function towerBattleEnd(sid: string, roleId: string, serverId: numb
     }
 }
 
-async function startHangUp(roleId: string, roleName: string) {
+/**
-    await HangUpRecordModel.initRecord(roleId, roleName);
+ * 创建下一层记录
+ * @param roleId 
+ * @param nextTowerLv 下一层塔
+ */
+export async function createNewTowerRecord(roleId: string, nextTowerLv: number) {
+    const nextTowerInfo = gameData.tower.get(nextTowerLv);
+    if (nextTowerInfo) {
+        const { warArray } = nextTowerInfo;
+        const sts = warArray.map(id => {
+            return { warId: id, status: false };
+        });
+
+        await TowerRecordModel.createRecord({ roleId, lv: nextTowerLv, warStatus: sts });
+    }
+}
+
+/**
+ * 当可以挂机的时候开始挂机
+ * @param roleId 
+ * @param roleName 
+ * @param towerLv 当前楼层，升过级之后的层
+ */
+export async function checkAndStartHungUp(roleId: string, roleName: string, towerLv: number) {
+    if (towerLv - 1 == dicParam.TOWER_HANG_UP.TOWER_HANG_UP_ENABLE_LV) {
+        await HangUpRecordModel.initRecord(roleId, roleName, towerLv);
+    }
+}
+
+/**
+ * 是否可以挂机，如果是10，那么要打过10层，即11层时可以开始挂机
+ * @param towerLv 
+ * @returns 
+ */
+export function canHunUp(towerLv: number) {
+    return towerLv - 1 >= dicParam.TOWER_HANG_UP.TOWER_HANG_UP_ENABLE_LV
 }
 
 export async function calcuHangUpReward(role: RoleType, speedUp = false, speedUpCnt = 1, curTime = new Date()) {
     let { roleId, towerLv = 1, hangUpSpdUpCnt = 0, lastSpdUpTime, vipStartTime } = role;
-    if (towerLv - 1 < dicParam.TOWER_HANG_UP.TOWER_HANG_UP_ENABLE_LV) {
+    if (!canHunUp(towerLv)) {
         return false
     }
 

shared/consts/constModules/selectConst.ts

@@ -49,4 +49,4 @@ export enum FRIEND_SHIP_SELECT {
     GET_FRIEND_VALUE = 'friendValue friendLv'
 }
 
-export const ENTERY_ROLE_PICK = ['roleId', 'roleName', 'serverId', 'ce', 'topLineupCe', 'coin', 'lv', 'exp', 'vLv', 'gold', 'heros', 'jewels', 'consumeGoods', 'title', 'teraphs', 'showLineup', 'heads', 'head', 'frames', 'frame', 'spines', 'spine', 'hasGuild', 'guildCode', 'todayZeroPoint', 'apJson', 'skins', 'totalPay', 'guide', 'hasInit', 'renameCnt', 'totalCost', 'guildName'];
+export const ENTERY_ROLE_PICK = ['roleId', 'roleName', 'serverId', 'ce', 'topLineupCe', 'coin', 'lv', 'exp', 'vLv', 'gold', 'heros', 'jewels', 'consumeGoods', 'title', 'teraphs', 'showLineup', 'heads', 'head', 'frames', 'frame', 'spines', 'spine', 'hasGuild', 'guildCode', 'todayZeroPoint', 'apJson', 'skins', 'totalPay', 'guide', 'hasInit', 'renameCnt', 'totalCost', 'guildName', 'isVip'];

shared/consts/statusCode.ts

@@ -104,6 +104,8 @@ export const STATUS = {
     TOWER_HANG_UP_NOT_START: { code: 20518, simStr: '挂机尚未开启' },
     TOWER_REF_CNT_NOT_ENOUGH: { code: 20519, simStr: '派遣刷新次数不足' },
     TOWER_HERO_FORBIDDEN: { code: 20520, simStr: '该武将不可使用' },
+    TOWER_CANNOT_SKIP: { code: 20521, simStr: '该层不可跳过' },
+    TOWER_SKIP_POWER_NOT_ENOUGH: { code: 20522, simStr: '战力不足不可跳过' },
     // 寻宝（共斗） 20600 - 20699
     COM_BATTLE_DUP_ENTER: { code: 20601, simStr: '不能重复加入' },
     COM_BATTLE_BLUEPRT_NOT_FOUND: { code: 20602, simStr: '藏宝图不足' },

shared/db/HangUpRecord.ts

@@ -1,6 +1,5 @@
 import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
-import * as dicParam from '../pubUtils/dicParam';
 
 class Goods {
   @prop({ required: true })
@@ -38,12 +37,12 @@ export default class HangUpRecord extends BaseModel {
   @prop({ required: true, default: false })
   received: boolean; // 是否已经领取，true-领取，false-未领取
 
-  public static async initRecord(roleId: string, roleName: string, lean = true) {
+  public static async initRecord(roleId: string, roleName: string, towerLv: number) {
     // console.log('****** initRecord before')
     const curTime = new Date();
     const recDoc = new HangUpRecordModel();
-    const update = Object.assign(recDoc.toJSON(), {roleId, roleName, startTime: curTime, startLv: dicParam.TOWER_HANG_UP.TOWER_HANG_UP_ENABLE_LV + 1});
+    const update = Object.assign(recDoc.toJSON(), {roleId, roleName, startTime: curTime, towerLv});
-    const rec: HangUpRecordType = await HangUpRecordModel.findOneAndUpdate({roleId, startLv: dicParam.TOWER_HANG_UP.TOWER_HANG_UP_ENABLE_LV + 1}, { $setOnInsert: update }, {upsert: true, new: true}).lean(lean);
+    const rec: HangUpRecordType = await HangUpRecordModel.findOneAndUpdate({roleId, startLv: towerLv}, { $setOnInsert: update }, {upsert: true, new: true}).lean();
     
     // console.log('****** initRecord after')
     return rec;

shared/db/TowerRecord.ts

@@ -21,7 +21,7 @@ export default class TowerRecord extends BaseModel {
   roleId: string;					// 角色 id
   @prop({ required: true, default: 1 })
   lv: number;                       // 天梯层数
-  @prop({ required: true, default: [] })
+  @prop({ required: true, default: [], type: Number })
   heroes: Array<number>;            // 本层已使用武将
   @prop({ required: true, type: WarStatus, default: [], _id: false })
   warStatus: Array<WarStatus>;
@@ -73,6 +73,13 @@ export default class TowerRecord extends BaseModel {
     }
   }
 
+  // 跳过当前层
+  public static async skipTower(roleId: string, curLv: number, heroes: number[]) {
+    let rec: TowerRecordType = await TowerRecordModel.findOneAndUpdate({ roleId, lv: curLv, 'warStatus.status': false }, { 
+      $set: { 'warStatus.$.status': true, heroes, passed: true },
+    }, { new: true }).lean()
+    return rec;
+  }
 
   public static async getRecordByLv(roleId: string, lv: number, lean = true) {
     const rec: TowerRecordType = await TowerRecordModel.findOne({roleId, lv}).lean(lean);

shared/pubUtils/dictionary/DicTower.ts

@@ -12,6 +12,8 @@ export interface DicTower {
     readonly reward: Array<RewardInter>;
     // 收集奖励
     readonly rewardOfcollect: Array<RewardInter>;
+    // 是否可以一键跳过
+    readonly canSkip: boolean;
 }
 
 
@@ -25,6 +27,7 @@ export function loadTower() {
         o.warArray = parseNumberList(o.warArray);
         o.reward = parseGoodStr(o.reward);
         o.rewardOfcollect = parseGoodStrOfCollect(o.rewardOfcollect);
+        o.canSkip = true;
         dicTower.set(o.towerFloor, o);
     });
     arr = undefined;

shared/pubUtils/dictionary/DicWar.ts

@@ -39,6 +39,8 @@ export interface DicWar {
     readonly teammateReward: Array<{id: number, count: number}>;
     // 镇念塔禁用角色
     readonly fobiddenCharactor: Array<{type: number, id: number}>;
+    // 推荐战力
+    readonly recommendedPower: number;
     // 远征随机buff
     readonly mapseid: number[];
     // 秘境类型
@@ -51,6 +53,8 @@ export interface DicWar {
     readonly winReward: Map<number, number|RewardInter[]>;
     // 练兵场失败奖励
     readonly failReward: Map<number, number|RewardInter[]>;
+    // 上场数量
+    readonly minHeroNum: number;
 }
 
 export const dicWar = new Map<number, DicWar>();
@@ -98,6 +102,7 @@ export function loadWar() {
             }
             dicWar.set(o.war_id, o);
             if(!!o.heroId) dicHeroIdByWar.set(o.war_id, o.heroId);
+            if(o.HeroNum) o.minHeroNum = parseInt(o.HeroNum.split('&')[0]);
         });
     }
 }