名将擂台：跑马灯&任务

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

@@ -16,6 +16,8 @@ import { getHeroesAttributes } from '../../../services/playerCeService';
 import { checkBattleHeroesByHid } from '../../../services/normalBattleService';
 import { ServerlistModel } from '../../../db/Serverlist';
 import { saveLadderDefCeByData } from '../../../services/redisService';
+import { pushLadderTopChangeMsg } from '../../../services/sysChatService';
+import { checkTaskInLadderEnd, checkTaskInLadderStart, checkTaskInLadderSweep } from '../../../services/task/taskService';
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -62,6 +64,7 @@ export class LadderHandler {
     async chooseOpp(msg: { roleId: string, rank: number, myRank: number }, session: BackendSession) {
         let roleId = session.get('roleId');
         let serverId = session.get('serverId');
+        let sid = session.get('sid');
         let { roleId: targetRoleId, rank, myRank } = msg;
         // 检查双方排名等，不行的刷新对手回去
         let ladderData = await LadderMatchModel.findByRoleId(roleId);
@@ -98,6 +101,7 @@ export class LadderHandler {
         pinus.app.rpc.systimer.systimerRemote.setLadderCountDown.broadcast(rec.battleCode, rec.checkTime, LADDER_STATUS.CHECK);
 
         let result = await getLadderOppDetailData(rec);
+        await checkTaskInLadderStart(serverId, roleId, sid);
         return resResult(STATUS.SUCCESS, {
             status,
             challengeCnt: ladderData.challengeCnt,
@@ -162,6 +166,7 @@ export class LadderHandler {
     async battleEnd(msg: { battleCode: string, isSuccess: boolean }, session: BackendSession) {
         let roleId = session.get('roleId');
         let roleName = session.get('roleName');
+        let serverId = session.get('serverId');
         let sid = session.get('sid');
         let { battleCode, isSuccess } = msg;
 
@@ -185,6 +190,9 @@ export class LadderHandler {
             await battleEndWhenChange(defLadderMatch);
             result.setOppPlayers(oppPlayers);
             rec = await LadderMatchRecModel.battleEnd(battleCode, isSuccess, atkLadderMatch.rank, defLadderMatch? defLadderMatch.rank: rec.attackInfo.oldRank);
+            if(atkLadderMatch.rank == 1) {
+                pushLadderTopChangeMsg(roleId, roleName, serverId);
+            }
         } else {
             rec = await LadderMatchRecModel.battleEnd(battleCode, isSuccess);
         }
@@ -196,11 +204,13 @@ export class LadderHandler {
         // 获取奖励
         let { battleGoods, breakGoods } = await ladderBattleEndReward(roleId, roleName, sid, rank, isSuccess, historyRank, 1);
 
+        await checkTaskInLadderEnd(serverId, roleId, sid, isSuccess, historyRank, atkLadderMatch.rank);
         return resResult(STATUS.SUCCESS, {...pick(result, ['rank', 'historyRank', 'challengeCnt','status', 'time', 'oppPlayers']), battleGoods, breakGoods});
     }
 
     // 8. 战5次（扫荡）
     async battleSweep(msg: { roleId: string, rank: number, count: number }, session: BackendSession) {
+        let serverId = session.get('serverId');
         let roleId = session.get('roleId');
         let roleName = session.get('roleName');
         let sid = session.get('sid');
@@ -229,7 +239,7 @@ export class LadderHandler {
 
         // 获取奖励
         let { battleGoods } = await ladderBattleEndReward(roleId, roleName, sid, rank, true, rank, count);
-
+        await checkTaskInLadderSweep(serverId, roleId, sid, count)
         return resResult(STATUS.SUCCESS, {
             challengeCnt: ladderData.challengeCnt,
             battleGoods

game-server/app/servers/role/handler/heroHandler.ts

@@ -11,7 +11,7 @@ import { ItemInter, RewardInter } from '../../../pubUtils/interface';
 import { getDropItems, FIGURE_UNLOCK_CONDITION, ITID } from '../../../consts/constModules/itemConst'
 import { pushComposeOrangeHero, pushHeroQualityUpMsg, pushHeroStarMax, pushHeroWakeUp } from '../../../services/chatService';
 import { PvpDefenseModel } from '../../../db/PvpDefense';
-import { checkTask, checkTaskInHeroQUalityUp, checkTaskInHeroStarUp, checkTaskInHeroTrain, checkTaskInHeroWakeUp } from '../../../services/task/taskService';
+import { checkTask, checkTaskInHeroGiveFavor, checkTaskInHeroQUalityUp, checkTaskInHeroStarUp, checkTaskInHeroTrain, checkTaskInHeroWakeUp } from '../../../services/task/taskService';
 import { isNumber, pick } from 'underscore';
 import { updateEplaces } from '../../../services/equipService';
 import { addConnect, addConsumeToHero, checkUnlockTalentCondition, initSkinTalent, updateSkinTalent } from '../../../services/roleService';
@@ -475,8 +475,9 @@ export class HeroHandler {
         }
 
         let updateConsume = addConsumeToHero(hero.consumes, material);
+        let newConnections = addConnect(connections, { shipId, level: newLevel, exp: newExp });
         let update = {
-            connections: addConnect(connections, { shipId, level: newLevel, exp: newExp }),
+            connections: newConnections,
             consumes: updateConsume
         }
 
@@ -484,7 +485,7 @@ export class HeroHandler {
         let { curHero } = await calculateCeWithHero(HERO_SYSTEM_TYPE.CONNECT, roleId, serverId, sid, hero.hid, update);
         if(isLv) {
             // await unlockFigure(sid, roleId, [{ type: FIGURE_UNLOCK_CONDITION.HERO_FAVOR, paramHid: curHero.hid, paramFavourLv: curHero.favourLv }]);
-            await checkTask(serverId, roleId, sid, TASK_TYPE.HERO_CONNECT, { connectLv: newLevel })
+            await checkTaskInHeroGiveFavor(serverId, roleId, sid, shipId, newConnections, connections);
         }
         return resResult(STATUS.SUCCESS, { curHero: { ...pick(curHero, ['hid', 'connections']), shipId } });
     }

game-server/app/services/ladderService.ts

@@ -281,6 +281,12 @@ export async function ladderTimeout(battleCode: string, status: LADDER_STATUS) {
     }
 }
 
+/**
+ * 结算时候设置排行、发送推送、刷新对手、发送跑马灯
+ * @param ladderMatch 
+ * @param isAtk 
+ * @returns 
+ */
 export async function battleEndWhenChange(ladderMatch: LadderMatchType) {
     if(!ladderMatch) return;
 

game-server/app/services/sysChatService.ts

@@ -144,6 +144,13 @@ export async function pushVestigeFirstMsg(roleId: string, roleName: string, serv
     return result;
 }
 
+export async function pushLadderTopChangeMsg(roleId: string, roleName: string, serverId: number | string) {
+    const content = JSON.stringify({ roleId, roleName });
+    const msgData = await createGroupMsg(roleId, roleName, CHANNEL_PREFIX.SYS, `${serverId}`, MSG_TYPE.RICH_TEXT, MSG_SOURCE.LADDER_FIRST_CHANGE, content, null, null);
+    await pushGroupMsgToRoom(msgData);
+    return msgData;
+}
+
 export async function createMarqueeMsg(roleId: string, roleName: string, serverId: number | string, content: string) {
     const msgData = await createGroupMsg(roleId, roleName, CHANNEL_PREFIX.SYS, `${serverId}`, MSG_TYPE.RICH_TEXT, MSG_SOURCE.SEND_MARQUEE, content, null, null);
     return msgData;

game-server/app/services/task/taskObj.ts

@@ -531,8 +531,10 @@ export class CheckSingleTask {
             //     }
             case TASK_TYPE.HERO_CONNECT: // 16. 激活x次 x星 武将羁绊
                 {
-                    let { connectLv } = param;
+                    let { shipId, connections, oldConnections } = param;
-                    if(dicTaskParam[1] == connectLv) {
+                    let oldConnectLv = oldConnections.find(cur => cur.shipId == shipId)?.level||0;
+                    let connectLv = connections.find(cur => cur.shipId == shipId)?.level||0;
+                    if(dicTaskParam[1] <= connectLv && dicTaskParam[1] > oldConnectLv) {
                         result = { inc: 1 };
                     }
                     break;
@@ -1268,6 +1270,48 @@ export class CheckSingleTask {
                     result = { inc: 1 };
                     break;
                 }
+            case TASK_TYPE.LADDER_CNT: // 121. 名将擂台挑战x次
+                {
+                    let { count } = param;
+                    result = { inc: count };
+                    break;
+                }
+            case TASK_TYPE.LADDER_SUCCESS_CNT: // 122. 名将擂台挑战胜利x次
+                {
+                    let { isSuccess, count } = param;
+                    if(isSuccess) {
+                        result = { inc: count };
+                    }
+                    break;
+                }
+            case TASK_TYPE.LADDER_RANK: // 123. 名将擂台排名
+                {
+                    let { oldLadderRank, ladderRank } = param;
+                    if(ladderRank < oldLadderRank && dicTaskParam[0] >= ladderRank) {
+                        result = { inc: 1 };
+                    }
+                    break;
+                }
+            case TASK_TYPE.CONNECT_ONE_HERO_MAX_LV: // 124. 单个武将其中最高等级的羁绊达X级
+                {
+                    let { connections, oldConnections } = param;
+                    let oldMaxLv = Math.max(...connections.map(cur => cur.level))||0;
+                    let maxLv = Math.max(...oldConnections.map(cur => cur.level))||0;
+                    if(dicTaskParam[0] <= oldMaxLv && dicTaskParam[0] > maxLv) {
+                        result = { inc: 1 };
+                    }
+                    break;
+                }
+            case TASK_TYPE.CONNECT_ONE_HERO_SUM_LV: // 125. 单个武将3条羁绊总共提升X级
+                {
+                    let { connections, oldConnections } = param;
+                    let oldSumLv = connections.reduce((pre, cur) => pre + cur.level, 0);
+                    let sumLv = oldConnections.reduce((pre, cur) => pre + cur.level, 0);
+                    if(dicTaskParam[0] <= oldSumLv && dicTaskParam[0] > sumLv) {
+                        result = { inc: 1 };
+                    }
+                    break;
+                }
         }
         return result
     }

game-server/app/services/task/taskService.ts

@@ -3,7 +3,7 @@ import { pinus, FrontendOrBackendSession } from 'pinus';
 import { resResult, shouldRefresh } from '../../pubUtils/util';
 import { STATUS, TASK_TYPE, TASK_FUN_TYPE, SHOP_REFRESH_TYPE, WAR_TYPE, PUSH_ROUTE, POP_UP_SHOP_CONDITION_TYPE } from '../../consts';
 import { TaskParamInter, TaskListReturn } from '../../domain/roleField/task';
-import { EPlace, HeroType } from '../../db/Hero';
+import { Connect, EPlace, HeroType } from '../../db/Hero';
 import { HeroScores } from '../../db/PvpHistoryOpp';
 import { ItemInter, RewardInter } from '../../pubUtils/interface';
 import { UserTaskModel, UserTaskType } from '../../db/UserTask';
@@ -314,6 +314,35 @@ export async function checkTaskInDonate(serverId: number, roleId: string, sid: s
     await task.saveAndPush(sid);
 }
 
+// 名将擂台
+export async function checkTaskInLadderStart(serverId: number, roleId: string, sid: string) {
+    let task = new CheckTask(serverId, roleId);
+    task.setParam(TASK_TYPE.LADDER_CNT, { count: 1 });
+    await task.saveAndPush(sid);
+}
+
+export async function checkTaskInLadderEnd(serverId: number, roleId: string, sid: string, isSuccess: boolean, oldHistoryRank: number, newHistoryRank: number) {
+    let task = new CheckTask(serverId, roleId);
+    task.setParam(TASK_TYPE.LADDER_SUCCESS_CNT, { isSuccess, count: 1 });
+    task.setParam(TASK_TYPE.LADDER_RANK, { oldLadderRank: oldHistoryRank, ladderRank: newHistoryRank })
+    await task.saveAndPush(sid);
+}
+
+export async function checkTaskInLadderSweep(serverId: number, roleId: string, sid: string, count: number) {
+    let task = new CheckTask(serverId, roleId);
+    task.setParam(TASK_TYPE.LADDER_CNT, { count });
+    task.setParam(TASK_TYPE.LADDER_SUCCESS_CNT, { isSuccess: true, count });
+    await task.saveAndPush(sid);
+}
+
+export async function checkTaskInHeroGiveFavor(serverId: number, roleId: string, sid: string, shipId: number, connections: Connect[], oldConnections: Connect[]) {
+    let task = new CheckTask(serverId, roleId);
+    task.setParam(TASK_TYPE.HERO_CONNECT, { shipId, connections, oldConnections });
+    task.setParam(TASK_TYPE.CONNECT_ONE_HERO_MAX_LV, { connections, oldConnections });
+    task.setParam(TASK_TYPE.CONNECT_ONE_HERO_SUM_LV, { connections, oldConnections });
+    await task.saveAndPush(sid);
+}
+
 // 获取task状态
 export async function getCurTask(roleId: string, session: FrontendOrBackendSession) {
     let userTask = await UserTaskModel.findByRole(roleId);

shared/consts/constModules/chatConst.ts

@@ -80,6 +80,7 @@ export const MSG_SOURCE = {
     GUILD_RECURIT: 24,
     EQUIP_STAR_UP: 25,
     EQUIP_QUALITY_UP: 26,
+    LADDER_FIRST_CHANGE: 27,
 }
 
 export const DEFAULT_MSG_PER_PAGE = 10;

shared/consts/constModules/sysConst.ts

@@ -567,7 +567,7 @@ export const WAR_RELATE_TABLES = [
     FILENAME.DIC_GK_PROBATION,
     FILENAME.DIC_GK_ARMY_TRAIN,
     FILENAME.DIC_GK_ARMY_BOSS,
-    FILENAME.DIC_GK_LADDER,
+    // FILENAME.DIC_GK_LADDER,
 ]
 
 // 装备栏强化类型
@@ -760,6 +760,11 @@ export enum TASK_TYPE {
     BATTLE_EXPEDITION_START = 118,     // 挑战远征x次
     BATTLE_DUNGEON_START = 119,        // 挑战秘境x次
     GUILD_GOLD_DONATE = 120,                 // 军团元宝捐献x次
+    LADDER_CNT = 121,                   // 名将擂台挑战x次
+    LADDER_SUCCESS_CNT = 122,           // 名将擂台挑战胜利x次
+    LADDER_RANK = 123,                  // 名将擂台排名
+    CONNECT_ONE_HERO_MAX_LV = 124,      // 羁绊最高等级的那一级达到x级
+    CONNECT_ONE_HERO_SUM_LV = 125,      // 单个武将全部羁绊到达
 }
 
 // 任务累积类型

shared/db/LadderMatch.ts

@@ -126,7 +126,6 @@ export default class LadderMatch extends BaseModel {
     }
 
     public static async updateCe(roleId: string, hid: number, ce: number) {   
-        console.log('##### updateCe', roleId, hid, ce)
         const rec: LadderMatchType = await LadderMatchModel.findOneAndUpdate(
             { roleId }, 
             { $set: { 'defense.heroes.$[t].ce': ce } },

shared/domain/roleField/task.ts

@@ -1,4 +1,4 @@
-import { EPlace, HeroType } from "../../db/Hero";
+import { Connect, EPlace, HeroType } from "../../db/Hero";
 import { JewelType } from "../../db/Jewel";
 import { HeroScore } from "../battleField/pvp";
 
@@ -16,7 +16,9 @@ export class TaskParamInter {
     heroNum?: number;         // 武将数量
     trainCount?: number;      // 武将训练次数
     stageUpCnt?: number;      // 武将升阶次数
-    connectLv?: number;       // 羁绊等级
+    shipId?: number;          // 羁绊id
+    oldConnections?: Connect[]; // 旧的羁绊
+    connections?: Connect[];  // 羁绊
     isSuccess?: boolean;      // pvp是否胜利
     heroScores?: HeroScore[]; // pvp各武将积分
     eventType?: number;       // 奇遇类型
@@ -25,6 +27,8 @@ export class TaskParamInter {
     pvpRank?: number;         // pvp等级
     guildJob?: number;        // 军团职位
     isComplete?: boolean;     // 练兵场是否压制
+    oldLadderRank?: number;   // 名将擂台原排名
+    ladderRank?: number;      // 名将擂台排名
 
     oldLv?: number;           // 原武将等级，原玩家等级
     oldStar?: number;         // 原武将星级

shared/pubUtils/dictionary/DicLadderDifficultRatio.ts

@@ -8,10 +8,6 @@ export interface DicLadderDifficultRatio {
     readonly id: number;
     // 排名
     readonly rank: number;
-    // 强度倍率
-    readonly value: number;
-    // 次级属性
-    readonly secondAttrLevel: number;
     // 等级
     readonly level: number;
     // 关卡id