奇遇推送优化，不需要每次传app直接使用pinus.app

game-server/app/servers/battle/filter/checkEventFilter.ts

@@ -15,7 +15,7 @@ Filter.prototype.before = function (routeRecord: RouteRecord, msg: any, session:
 };
 
 Filter.prototype.after = function (err: Error, routeRecord: RouteRecord, msg: any, session: FrontendOrBackendSession, resp: any, next: HandlerCallback) {
-    return checkEvent(this.app, session).then(()=>{
+    return checkEvent(session).then(()=>{
         next(err);
     }).catch(e => {
         console.error(e);

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

@@ -720,7 +720,7 @@ export class ComBattleHandler {
 
         await ComBattleTeamModel.updateRewardSt(teamCode, roleId, true);
         const goods = await handleFixedReward(roleId, roleName, sid, roleSt.fixReward, 1);
-        let actordata = await roleLevelup(roleId, warInfo.kingExp, this.app, session);// 主公升级经验
+        let actordata = await roleLevelup(roleId, warInfo.kingExp, session);// 主公升级经验
 
         return resResult(STATUS.SUCCESS, { battleGoods: goods, ...actordata, teamInfo: {status, teamCode, roleStatus, bossHpArr} });
     }

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

@@ -118,7 +118,7 @@ export class EventBattleHandler {
             session.push('eventStatus', () => {});
         }
         // 推送消息刷新
-        await checkEvent(this.app, session, true);
+        await checkEvent(session, true);
         return resResult(STATUS.SUCCESS, {
                 isSuccess,
                 eventCode: result.eventCode,

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

@@ -263,7 +263,7 @@ export class ExpeditionBattleHandler {
         let warReward = new WarReward(roleId, roleName, sid, battleId, isSuccess);
         let reward = await warReward.saveReward(1);
         
-        let actordata = await roleLevelup(roleId, isSuccess?warInfo.kingExp:0, this.app, session);// 主公升级经验
+        let actordata = await roleLevelup(roleId, isSuccess?warInfo.kingExp:0, session);// 主公升级经验
         if(isSuccess) {
             // 更新下一关状态
             await ExpeditionWarRecordModel.updateStatus(expeditionCode, expeditionId + 1, EXPEDITION_WAR_RECORD_STATUS.WAITING);    

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

@@ -189,8 +189,6 @@ export class NormalBattleHandler {
             return resResult(STATUS.BATTLE_ACTION_POINT_LACK);
         }
 
-        let channelService = this.app.get('channelService');
-
         let warReward = new WarReward(roleId, roleName, sid, battleId, isSuccess);
 
         let dailyNum = {};
@@ -205,9 +203,9 @@ export class NormalBattleHandler {
             dailyNum = Object.assign(dailyNum, checkResult.data)
         } else if (warInfo.warType == WAR_TYPE.EVENT) { 
             // 记录事件状态
-            await setBattleStatus(this.app, session, roleId, battleId, isSuccess, battleCode);
+            await setBattleStatus(session, roleId, battleId, isSuccess, battleCode);
         } else if (warInfo.warType == WAR_TYPE.TOWER) {
-            let towerEndResult = await towerBattleEnd(channelService, sid, roleId, serverId, battleCode, battleId, isSuccess, heroes);
+            let towerEndResult = await towerBattleEnd(sid, roleId, serverId, battleCode, battleId, isSuccess, heroes);
             if(towerEndResult) {
                 if(towerEndResult.status == -1) {
                     return towerEndResult.resResult;
@@ -230,7 +228,7 @@ export class NormalBattleHandler {
             let {warStar} = await RoleModel.findByRoleId(roleId);
             let condition1 = warStar.find(cur => cur.id == battleId);
             if(!condition1) {
-                await switchOnFunc(roleId, FUNC_OPT_TYPE.BATTLE_END, battleId, this.app, session);
+                await switchOnFunc(roleId, FUNC_OPT_TYPE.BATTLE_END, battleId, session);
                 warReward.setCondition(0, true);
             }
             // 是否首次3星
@@ -248,7 +246,7 @@ export class NormalBattleHandler {
         }, true);
         let { status } = updateResult;
 
-        let actordata = await roleLevelup(roleId, isSuccess?warInfo.kingExp:0, this.app, session);// 主公升级经验
+        let actordata = await roleLevelup(roleId, isSuccess?warInfo.kingExp:0, session);// 主公升级经验
 
         // 返回值：
         // towerStatus: false-本层未通过, true-本层已通过
@@ -309,7 +307,7 @@ export class NormalBattleHandler {
         let warReward = new WarReward(roleId, roleName, sid, battleId, true);
         let result = await warReward.saveReward(count);
 
-        let actordata = await roleLevelup(roleId, warInfo.kingExp * count, this.app, session)// 主公升级经验
+        let actordata = await roleLevelup(roleId, warInfo.kingExp * count, session)// 主公升级经验
 
         // 扫荡记录
         await BattleSweepRecordModel.saveBattleSweepRecordById(roleId, battleId, {

game-server/app/servers/connector/handler/entryHandler.ts

@@ -68,14 +68,14 @@ export class EntryHandler {
         session.on('closed', this.onUserLeave.bind(this));
 
         let channelService = self.app.get('channelService');
-        let channel = channelService.getChannel(`server-${role.serverId}`, true);
+        let channel = channelService.getChannel(role.roleId, true);
         if (channel.getMembers().indexOf(role.roleId) === -1) {
             channel.add(role.roleId, self.app.get('serverId'));
         }
 
         // put user into channel
-        console.log(JSON.stringify(self.app.rpc.battle))
+        // console.log(JSON.stringify(self.app.rpc.battle))
-        await self.app.rpc.battle.battleRemote.add.route(session)(role.roleId, self.app.get('serverId'), role.serverId, true);
+        // await self.app.rpc.battle.battleRemote.add.route(session)(role.roleId, self.app.get('serverId'), role.serverId, true);
         // let users = await self.app.rpc.chat.chatRemote.add.route(session)(role.roleId, self.app.get('serverId'), rid, true);
         let heros = await HeroModel.findByRole(role.roleId);
         let equips = await EquipModel.findbyRole(role.roleId);
@@ -89,7 +89,7 @@ export class EntryHandler {
         role['apJson'] = apJson;
         role['ce'] = reduceCe(role.ce);
 
-        await switchOnFunc(role.roleId, FUNC_OPT_TYPE.LEVEL_UP, role.lv, self.app, session);
+        await switchOnFunc(role.roleId, FUNC_OPT_TYPE.LEVEL_UP, role.lv, session);
         return resResult(STATUS.SUCCESS, { role });
     }
 
@@ -124,7 +124,7 @@ export class EntryHandler {
         let channelService = this.app.get('channelService');
         let channel = channelService.getChannel(roleId, true);
         channel.leave(roleId, sid);
-        this.app.rpc.battle.battleRemote.kick.route(session)(roleId, this.app.get('serverId'), serverId);
+        // this.app.rpc.battle.battleRemote.kick.route(session)(roleId, this.app.get('serverId'), serverId);
         // this.app.rpc.chat.chatRemote.kick.route(session, true)(session.uid, this.app.get('serverId'), session.get('rid'));
     }
 

game-server/app/services/battleService.ts

@@ -1,6 +1,6 @@
 import { HeroModel } from './../db/Hero';
 import { HangUpRecordModel } from './../db/HangUpRecord';
-import { ChannelService } from 'pinus';
+import { ChannelService, pinus } from 'pinus';
 import { HANG_UP_CONSTS, TOWER_TASK_CONST, REDIS_KEY } from './../consts';
 import { BattleRecordModel } from './../db/BattleRecord';
 import { TowerRecordModel } from './../db/TowerRecord';
@@ -46,7 +46,7 @@ export async function checkTowerWar(roleId: string, battleId: number, heroes: Ar
     }};
 }
 
-export async function towerBattleEnd(channelService: ChannelService, sid: string, roleId: string, serverId: number, battleCode: string, battleId: number, succeed: boolean, heroes: Array<number>) {
+export async function towerBattleEnd(sid: string, roleId: string, serverId: number, battleCode: string, battleId: number, succeed: boolean, heroes: Array<number>) {
     if (succeed) {
         let battleRec = await BattleRecordModel.getBattleRecordByCode(battleCode);
         if (battleRec.battleId != battleId) {
@@ -88,7 +88,7 @@ export async function towerBattleEnd(channelService: ChannelService, sid: string
             if (reward) towerReward = reward;
             if (towerLv == HANG_UP_CONSTS.ENABLE_LV) {
                 await startHangUp(roleId, roleName);
-                channelService.pushMessageByUids('hangUpEnable', {code: 200, data: {enable: true}}, [{uid: roleId, sid}]);
+                pinus.app.get('channelService').pushMessageByUids('hangUpEnable', {code: 200, data: {enable: true}}, [{uid: roleId, sid}]);
             }
         }
         return {

game-server/app/services/eventSercive.ts

@@ -1,4 +1,4 @@
-import { Application, FrontendOrBackendSession } from 'pinus';
+import { FrontendOrBackendSession, pinus } from 'pinus';
 import { getGamedata } from '../pubUtils/gamedata';
 import EventRecord, { EventRecordModel } from '../db/EventRecord';
 import { RoleModel } from '../db/Role';
@@ -37,21 +37,20 @@ export async function checkEventBattle(roleId: string, eventStatus: number, batt
 /**
  * 从关卡结算接口调用，保存战斗情况
  * 
- * @param app 
  * @param session 
  * @param roleId 
  * @param battleId 
  * @param isSuccess 
  * @param battleCode 
  */
-export async function setBattleStatus(app: Application, session: FrontendOrBackendSession, roleId: string, battleId: number , isSuccess: boolean, battleCode: string) {
+export async function setBattleStatus(session: FrontendOrBackendSession, roleId: string, battleId: number , isSuccess: boolean, battleCode: string) {
 
     let { BATTLE_SUCCESS, BATTLE_FAIL } = EVENT_RECORD_STATUS;
     let result = await EventRecordModel.setBattleStatus(roleId, battleId, battleCode, isSuccess?BATTLE_SUCCESS:BATTLE_FAIL);
     if (!result) {
         return { status: -1, resResult: resResult(STATUS.EVENT_INFO_NOT_FOUND) };
     } 
-    await checkEvent(app, session, true);
+    await checkEvent(session, true);
     return { status: 0, data: result };
 }
 
@@ -79,58 +78,53 @@ export function getEventTime(now: Date) {
 /**
  * 从挑战结算接口调用，挑战完主线某一关，开始刷奇遇关卡
  * 
- * @param app 
  * @param session 
  */
-export async function startEvent(app: Application, session: FrontendOrBackendSession) {
+export async function startEvent(session: FrontendOrBackendSession) {
 
     // console.log('*******setEventStatus')
     let roleId = session.get('roleId');
     let roleName = session.get('roleName');
-    let serverId = session.get('serverId');
+    let sid = session.get('sid');
-    let channelName = `server-${serverId}`;
     let event = await refreshEvent(1, roleId, roleName, 0, []); // 刷新初始的一件
     await RoleModel.setEventStatus(roleId, EVENT_STATUS.STARTING);
     session.set('eventStatus', EVENT_STATUS.STARTING);
     session.push('eventStatus', () => {});
-    pushEventMsg(app, roleId, channelName, { event }); // 推送
+    pushEventMsg(sid, roleId, { event }); // 推送
 
 }
 
 /**
  * 从filter调用，用于每次检查时间，获取事件并推送
  * 
- * @param app 
  * @param session 
  * @param isForce 即使不是12点和18点也强制刷新
  */
-export async function checkEvent(app: Application, session: FrontendOrBackendSession, isForce:boolean = false) {
+export async function checkEvent(session: FrontendOrBackendSession, isForce:boolean = false) {
 
     try {
 
         let roleId = session.get('roleId');
         let serverId = session.get('serverId');
         let funcs = session.get('funcs');
+        let sid = session.get('sid');
         if(roleId) {
 
             let roleName = session.get('roleName');
-            let channelName = `server-${serverId}`;
             let eventStatus = session.get('eventStatus')||EVENT_STATUS.WAITING;
             
             if(funcs && funcs.includes(FUNCS_ID.EVENT) && eventStatus == EVENT_STATUS.WAITING) {
-                await startEvent(app, session);
+                await startEvent(session);
             } else {
                 let eventTime = session.get('getEventTime')||0;
                 let now = new Date();
                 let t = getEventTime(now);
                 
-                let channel = app.get('channelService').getChannel(channelName, false);
+                if(eventTime < t || isForce) { // 第一次登陆后可以刷新了
-    
-                if(!!channel && (eventTime < t || isForce)) { // 第一次登陆后可以刷新了
     
                     let event = await getEvent(eventStatus, roleId, roleName);
                     if (eventStatus == EVENT_STATUS.STARTING || eventStatus == EVENT_STATUS.OPEN) {
-                        pushEventMsg(app, roleId, channelName, { event }); // 推送
+                        pushEventMsg(sid, roleId, { event }); // 推送
                         session.set('getEventTime', t);
                         session.push('getEventTime', () => {});
                     }
@@ -292,24 +286,18 @@ function randomPosition(positionStr: string, prePoint: Array<number>, curPoint:
 /**
  * 推送
  * 
- * @param app 
  * @param roleId 
- * @param channelName 
  * @param msg 
  */
-function pushEventMsg(app: Application, roleId: string, channelName: string, msg: any ) {
+function pushEventMsg(sid: string, roleId: string, msg: any ) {
-    let channelService = app.get('channelService');
+    let channelService = pinus.app.get('channelService');
     
     let param = { msg };
-    let channel = channelService.getChannel(channelName, false);
-    if(!!channel) {
-        let tsid = channel.getMember(roleId)['sid'];
 
-        channelService.pushMessageByUids('onSpecialEvent', param, [{
+    channelService.pushMessageByUids('onSpecialEvent', param, [{
-            uid: roleId,
+        uid: roleId,
-            sid: tsid
+        sid: sid
-        }]);
+    }]);
-    }
 }
 
 /**

game-server/app/services/funcSwitchService.ts

@@ -1,13 +1,12 @@
-import { Application, BackendSession, FrontendSession } from "pinus";
+import { BackendSession, FrontendSession, pinus } from "pinus";
 import { getGamedata } from "../pubUtils/gamedata";
-import Role, { RoleModel } from "../db/Role";
+import { RoleModel } from "../db/Role";
-import { FUNC_OPT_TYPE } from "../consts";
 
 // 开启功能
-export async function switchOnFunc(roleId: string, type: number, param: number, app: Application, session: (BackendSession|FrontendSession)) {
+export async function switchOnFunc(roleId: string, type: number, param: number, session: (BackendSession|FrontendSession)) {
 
-    const serverId = session.get('serverId');
     const dataFuncs = session.get('funcs');
+    const sid = session.get('sid');
     const dicFuncSwitch = getGamedata('dic_func_switch');
      
     let funcs = new Array<{id: number, desc: string, script: string}>(), addFuncs = new Array<number>();
@@ -18,14 +17,11 @@ export async function switchOnFunc(roleId: string, type: number, param: number,
         }
     }
 
-    let channelService = app.get('channelService');
+    if(funcs.length > 0) {
-    let channel = channelService.getChannel(`server-${serverId}`, false);
-    if(!!channel && funcs.length > 0) {
-        let tsid = channel.getMember(roleId)['sid'];
     
-        channelService.pushMessageByUids('onFuncSwitchOn', {funcs}, [{
+        pinus.app.get('channelService').pushMessageByUids('onFuncSwitchOn', {funcs}, [{
             uid: roleId,
-            sid: tsid
+            sid: sid
         }]);
     }
     const recs = await RoleModel.pushFuncs(roleId, addFuncs);

game-server/app/services/normalBattleService.ts

@@ -5,9 +5,9 @@ import { getLvByExp, getExpByLv } from '../pubUtils/gamedata';
 import { redisUserInfoUpdate } from './redisService';
 import { switchOnFunc } from './funcSwitchService';
 import { FUNC_OPT_TYPE } from '../consts';
-import { Application, BackendSession } from 'pinus';
+import { BackendSession } from 'pinus';
 
-export async function roleLevelup(roleId: string, kingExp: number, app: Application, session: BackendSession) {
+export async function roleLevelup(roleId: string, kingExp: number, session: BackendSession) {
     let role = await RoleModel.findByRoleId(roleId);
     let {lv = 1, exp = 0} = role;
     let newExp = exp + kingExp;
@@ -20,7 +20,7 @@ export async function roleLevelup(roleId: string, kingExp: number, app: Applicat
     
     role = await RoleModel.levelup(roleId, newLv, newExp);
     if(newLv > lv) { // 升级
-        await switchOnFunc(roleId, FUNC_OPT_TYPE.LEVEL_UP, newLv, app, session); 
+        await switchOnFunc(roleId, FUNC_OPT_TYPE.LEVEL_UP, newLv, session); 
         await redisUserInfoUpdate(roleId, [{field: 'lv', value: newLv}])
     }
     let actordata = [];