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

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 channelName = `server-${serverId}`;
+    let sid = session.get('sid');
     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(!!channel && (eventTime < t || isForce)) { // 第一次登陆后可以刷新了
+                
+                if(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 ) {
-    let channelService = app.get('channelService');
+function pushEventMsg(sid: string, roleId: string, msg: any ) {
+    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, [{
-            uid: roleId,
-            sid: tsid
-        }]);
-    }
+    channelService.pushMessageByUids('onSpecialEvent', param, [{
+        uid: roleId,
+        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 { FUNC_OPT_TYPE } from "../consts";
+import { RoleModel } from "../db/Role";
 
 // 开启功能
-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');
-    let channel = channelService.getChannel(`server-${serverId}`, false);
-    if(!!channel && funcs.length > 0) {
-        let tsid = channel.getMember(roleId)['sid'];
+    if(funcs.length > 0) {
     
-        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 = [];