ZYZ/game-server/app/util/routeUtil.ts

import { dispatch } from '../pubUtils/dispatcher';
import { Session, Application } from 'pinus';
import { redisClient } from '../services/redisService';
import { getGroupIdOfServer } from '../services/serverService';
import { SERVER_GROUP_FUN_TYPE } from '../consts';

export async function chat(session: Session, msg: any, app: Application, cb: (err: Error, serverId?: string) => void) {
    let chatServers = app.getServersByType('chat');

    if (!chatServers || chatServers.length === 0) {
        cb(new Error('can not find chat servers.'));
        return;
    }
    let id = session.get('chatServer')||(await dispatch(redisClient(), session.get('roleId'), chatServers, 'chat')).id;

    cb(null, id);
}

export async function battle(session: Session, msg: any, app: Application, cb: (err: Error, serverId?: string) => void) {
    let battleServers = app.getServersByType('battle');

    if (!battleServers || battleServers.length === 0) {
        cb(new Error('can not find battle servers.'));
        return;
    }

    let rid = session.get('roleId');
    let id = session.get('battleServer')||(await dispatch(redisClient(), rid, battleServers, 'battle')).id;
    cb(null, id);
}

export async function comBattle(session: Session, msg: any, app: Application, cb: (err: Error, serverId?: string) => void) {
    let battleServers = app.getServersByType('comBattle');

    if (!battleServers || battleServers.length === 0) {
        cb(new Error('can not find comBattle servers.'));
        return;
    }

    let rid = session.get('roleId');
    let needDispatch = false;

    if (msg.args && msg.args.length > 0) {
        for (let arg of msg.args) {
            if (!arg.route) continue;
            if (['comBattle.comBattleHandler.createTeam', 'comBattle.comBattleHandler.searchTeam'].indexOf(arg.route) !== -1) {
                needDispatch = true;
                rid = Math.random().toString(36).slice(-8);
                session.set('teamCode', rid);
            } else if (arg.route.indexOf('comBattle.comBattleHandler') !== -1) {
                if (arg.body.teamCode) {
                    needDispatch = true;
                    rid = arg.body.teamCode;
                }
            }
        }
    }

    if(needDispatch) {
        let id = (await dispatch(redisClient(), rid, battleServers, 'comBattle')).id;
        cb(null, id);
    } else {
        let id = session.get('comBattleServer')||(await dispatch(redisClient(), rid, battleServers, 'comBattle')).id;
        cb(null, id);
    }
}

export async function guild(session: Session, msg: any, app: Application, cb: (err: Error, serverId?: string) => void) {
    let guildServers = app.getServersByType('guild');

    if (!guildServers || guildServers.length === 0) {
        cb(new Error('can not find guild servers.'));
        return;
    }

    let rid = session.get('roleId');
    let needDispatch = false;

    if (msg.args && msg.args.length > 0) {
        for (let arg of msg.args) {
            if (!arg.route) continue;

            if (['guild.gateActivityHandler.getGateActivity',
                'guild.gateActivityHandler.checkBattle',      // 军团活动蛮夷入侵路由，按军团路由
                'guild.gateActivityHandler.action',
                'guild.gateActivityHandler.hitGate',
                'guild.gateActivityHandler.battleEnd',
                'guild.gateActivityHandler.debugGetPrivate',
                'guild.gateActivityHandler.debugStartActivity',
                'guild.gateActivityHandler.debugEndActivity'
            ].indexOf(arg.route) !== -1) {
                needDispatch = true;
                rid = session.get('guildCode');
            } else if (['guild.cityActivityHandler.getCityStatus',
                'guild.cityActivityHandler.declareCity',
                'guild.cityActivityHandler.checkBattle',
                'guild.cityActivityHandler.hitGate',
                'guild.cityActivityHandler.battleEnd'
            ].indexOf(arg.route) !== -1) {
                if (arg.body.cityId) {
                    let serverId = session.get('serverId');
                    needDispatch = true;
                    rid = `${serverId}_${arg.body.cityId}`;
                }
            } else if (['guild.raceActivityHandler.getRaceActivity',
                'guild.raceActivityHandler.leavePage',
                'guild.raceActivityHandler.join',
                'guild.raceActivityHandler.getRace',
                'guild.raceActivityHandler.useItem',
                'guild.raceActivityHandler.battleEnd',
            ].indexOf(arg.route) !== -1) {
                needDispatch = true;
                rid = session.get('serverId').toString();
            } else if (['guild.gvgBattleHandler.startMove',
                'guild.gvgBattleHandler.stopMove',
                'guild.gvgBattleHandler.teamSettle',
                'guild.gvgBattleHandler.teamLeave',
                'guild.gvgBattleHandler.battleEnd',
                'guild.gvgBattleHandler.battleStart',
                'guild.gvgBattleHandler.getAreaTeams',
                'guild.gvgBattleHandler.useItem',
                'guild.gvgBattleHandler.reviveTeam',
                'guild.gvgBattleHandler.saveTeam',
                'guild.gvgBattleHandler.getCity',
                'guild.gvgBattleHandler.checkMyTeam',
                'guild.gvgBattleHandler.enterCity',
                'guild.gvgBattleHandler.leaveCity',
                'guild.gvgBattleHandler.getRankByCity',
                'guild.gvgBattleHandler.getAreaOfMyTeam',
                'guild.gvgBattleHandler.getOppTeam',
                'guild.gvgBattleHandler.debugAddRobots',
                'guild.gvgBattleHandler.debugMoveRobots',
                'guild.gvgBattleHandler.debugStopMoveRobot',
                'guild.gvgBattleHandler.debugAttacks',
            ].indexOf(arg.route) !== -1) {
                if (arg.body.cityId) {
                    let serverId = session.get('serverId');
                    let groupId = await getGroupIdOfServer(serverId, SERVER_GROUP_FUN_TYPE.GVG);
                    needDispatch = true;
                    rid = `${groupId}_${arg.body.cityId}`;
                }
            } else if ([
                'guild.auctionHandler.offer'
            ].indexOf(arg.route) != -1) {
                if(arg.body.code) {
                    needDispatch = true;
                    rid = arg.body.code;
                }
            }
        }
    }

    if(needDispatch) {
        let id = (await dispatch(redisClient(), rid, guildServers, 'guild')).id;
        cb(null, id);
    } else {
        let id = session.get('guildServer')||(await dispatch(redisClient(), rid, guildServers, 'guild')).id;
        cb(null, id);
    }
}

export async function activity(session: Session, msg: any, app: Application, cb: (err: Error, serverId?: string) => void) {
    let activityServers = app.getServersByType('activity');
    if (!activityServers || activityServers.length === 0) {
        cb(new Error('can not find activity servers.'));
        return;
    }
    let id = session.get('activityServer')||(await dispatch(redisClient(), session.get('roleId'), activityServers, 'activity'));
    cb(null, id);
}

export async function gm(session: Session, msg: any, app: Application, cb: (err: Error, serverId?: string) => void) {
    let gmServers = app.getServersByType('gm');

    if (!gmServers || gmServers.length === 0) {
        cb(new Error('can not find gm servers.'));
        return;
    }

    let res = await dispatch(redisClient(), session.get('roleId'), gmServers, 'gm');
    cb(null, res.id);
}

export async function role(session: Session, msg: any, app: Application, cb: (err: Error, serverId?: string) => void) {
    let roleServers = app.getServersByType('role');

    if (!roleServers || roleServers.length === 0) {
        cb(new Error('can not find activity servers.'));
        return;
    }

    let id = session.get('roleServer')||(await dispatch(redisClient(), session.get('roleId'), roleServers)).id;
    cb(null, id);
}

export async function order(session: Session, msg: any, app: Application, cb: (err: Error, serverId?: string) => void) {
    let orderServers = app.getServersByType('order');

    if (!orderServers || orderServers.length === 0) {
        cb(new Error('can not find activity servers.'));
        return;
    }

    let id = session.get('orderServer')||(await dispatch(redisClient(), session.get('roleId'), orderServers, 'order')).id;
    cb(null, id);
}