import { EEventType, Channel, Operate } from './../role/EEnum';
/**
 * agent 类，客户端网络连接代理，用于接收发送与客户端相关的协议包。
 */

import AgentBase from "./AgentBase";
import AgentMgr from "./AgentMgr";
import GMMgr from "../core/GMMgr";
import Signal from "../core/Signal";
import GameUtil from "../core/GameUtil";
import Player from "../object/Player";
import MapMgr from "../core/MapMgr";
import PlayerMgr from "../object/PlayerMgr";
import ChargeSum from "../core/ChargeSum";
import BangMgr from "../bang/BangMgr";
import World from "../object/World";
import PaiHangMgr from "../core/PaiHangMgr";
import Shop from "../object/Shop";
import GoodsMgr from "../item/GoodsMgr";
import ShopItem from "../object/ShopItem";
import MallMgr from "../core/MallMgr";
import ZhenbukuiMgr from "../activity/ZhenbukuiMgr";
import DB from "../utils/DB";
import BattleMgr from "../battle/BattleMgr";
import ActivityMgr from "../activity/ActivityMgr";
import ActivityDefine from "../activity/ActivityDefine";
import RelationMgr from "../object/RelationMgr";
import TeamMgr from "../core/TeamMgr";
import NpcMgr from "../core/NpcMgr";
import TaskConfigMgr from "../task/TaskConfigMgr";
import NpcConfigMgr from "../core/NpcConfigMgr";
import LotteryMgr from "../core/LotteryMgr";
import EquipMgr from "../object/EquipMgr";
import WorldRewardMgr from "../activity/WorldRewardMgr"
import PalaceFight from "../activity/PalaceFight";
import SKDataUtil from "../gear/SKDataUtil";
import SKLogger from "../gear/SKLogger";
import ItemUtil from "../core/ItemUtil";
import BoxMgr from "../core/BoxMgr";
import { MsgCode } from "../role/EEnum";
import EventBase from '../event/EventBase';
import GiveNpcItem from '../event/GiveNpcItem';
import KillDynamicNpcState from '../event/KillDynamicNpcState';
import EventStateBase from '../event/EventStateBase';
import TalkEventState from '../event/TalkEventState';
import Npc from '../core/Npc';
import JingJiChang from "../activity/JingJiChang";
import GameConf from "../../conf/GameConf";
import SignInMgr from "../core/SignInMgr";
import GTimer from "../common/GTimer";
import RespondentsMgr from "../core/RespondentsMgr";
import DialMgr from "../core/DialMgr";
import ChangeCard from "../object/ChangeCard";
import SKCxfUtil from "../gear/SKCxfUtil";
import FivePhases from "../object/FivePhases";
import DWorld from "../object/DWorld";
import SatAssembly from '../activity/SatAssembly';
import SpecialEffect from "../object/SpecialEffect";
import PetSupport from "../object/PetSupport";
import Ofuda from "../object/Ofuda";
import FactionWar from '../activity/FactionWar';
import RoleTaskMgr from "../core/RoleTaskMgr";
import DebrisMall from '../core/DebrisMall';
import Interface from '../core/Interface';
import Currency from "../activity/Currency";
import Marry from "../object/Marry";
import TianTi from '../activity/TianTi';
import JIngChanSongFuMgr from '../JingChanSongFu/JIngChanSongFuMgr';


export default class Agent extends AgentBase {
    accountid: number;
    roleId: number;
    roleName: string;
    token: string;
    loginstep: number;
    player: Player;

    constructor(socket: any) {
        super(socket);
        this.accountid = -1; // agent 绑定的玩家id
        this.roleId = -1;
        this.roleName = "未知";
        this.token = ""; // agent 登录token
        this.loginstep = 0;
    }

    close() {
        super.close();
        AgentMgr.shared.delAgent(this.id);
        if (this.player != null) {
            this.player.playerOffline();
            this.player = null;
        }
        SKLogger.debug(`玩家[${this.roleId}:${this.roleName}]SOCKET断开连接:AgentID[${this.id}]`);
    }

    gm_command(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        GMMgr.shared.exec(player, data.commands);
    }

    // 请求登录
    c2s_login(data: any) {
        let accountid = data.accountid;
        let roleid = data.roleid;
        let token = Signal.shared.getLoginToken(accountid);
        // 登录失败，需重新登录
        if (data.token != token || roleid == undefined) {
            SKLogger.warn(`玩家[agentId=${this.id},角色:${roleid}]登录异常:TOKEN[${data.token}:${token}]无效!`);
            this.close();
            return;
        }
        this.accountid = accountid;
        this.roleId = roleid;
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player != null) {
            this.player = player;
            this.player.setAgent(this);
            this.player.playerLogined();
            this.roleName = this.player.name;
            SKLogger.debug(`玩家[${this.roleId}:${this.roleName}][agentId=${this.id}]重新连接`);
            return;
        }
        this.readDB();
    }

    readDB() {
        SKLogger.info(`玩家[agentId=${this.id},角色:${this.roleId}]读表中...`);
        let self = this;
        if (this.roleId != undefined) {
            DB.loginByRoleid(this.roleId, (code: any, data: any) => {
                if (code == MsgCode.SUCCESS) {
                    self.doLogin(data);
                } else {
                    self.close();
                }
            });
        }

    }

    doLogin(data: any) {
        this.player = new Player();
        this.player.setAgent(this);
        this.player.setDB(data);
        if (this.player.x == -1 || this.player.y == -1) {
            this.player.x = MapMgr.shared.getMap(this.player).map_data.startPos.x;
            this.player.y = MapMgr.shared.getMap(this.player).map_data.startPos.y;
        }
        SKLogger.info(`玩家[${this.player.roleid}:${this.player.name}][agentId:${this.id}]登录成功!`);
        this.player.playerLogined();
        this.roleName = this.player.name;
    };

    // 其他设备登录
    otherLogin() {
        if (this.player) {
            this.player.send("s2c_otherlogin");
        }
        this.player = null;
    }

    c2s_relogin(data: any) {
        let roleid = data.roleid;
        let otheragent = AgentMgr.shared.getAgentByAccountid(roleid);
        if (otheragent) {
            otheragent.close();
        }
        // 处理掉线玩家
        let player = PlayerMgr.shared.getPlayerByRoleId(roleid);
        if (player) {
            if (player.offline == true) {
                player.setAgent(this);
                player.playerRelogin();
                return;
            }
            player.agent.close();
            player.setAgent(this);
            player.playerRelogin();
            return;
        }
    }

    c2s_enter_game(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            player.onEnterGame();
            player.activateScheme();
        }
    }

    c2s_change_map(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            player.changeMap(data);
        }
    }

    c2s_create_team(data: any) {
        const player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            TeamMgr.shared.creatTeam(player, data);
        }
    }

    c2s_match_team(data: any) {
        const player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            TeamMgr.shared.matchTeam(player);
        }
    }

    //申请队伍
    c2s_requst_team(data: any) {
        const player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            if (player.inPrison) {
                player.send('s2c_notice', {
                    strRichText: '老实点，天王老子都不会收留你。'
                });
            }
            let playerlist = TeamMgr.shared.getTeamPlayer(data.teamid);
            for (let player1 of playerlist) {
                if (player1.isleader) {
                    if (player.mapid == 3001 && player.bangid != player1.bangid) {
                        player.send_notice("你们不是一个帮派！");
                        return;
                    }
                    if (player1.mapid == 3001 && player.mapid != 3001) {
                        player.send_notice("队长正在参加帮战，先去找npc报名吧！");
                        return;
                    }
                    if (player1.mapid == 1213 && player.mapid != 1213) {
                        player.send_notice("队长正在参加水陆大会，先去找npc报名吧！");
                        return;
                    }
                    if (player1.mapid == 4004 && player.mapid != 4004) {
                        player.send_notice("队长正在参加水陆大会，先去找npc报名吧！");
                        return;
                    }
                }
            }
            TeamMgr.shared.requestTeam(player, data.teamid);
        }
    }

    //离开队伍
    c2s_leave_team(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            TeamMgr.shared.leaveTeam(player);
        }
    }

    //移交队长
    c2s_transfer_team(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        let toPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player && toPlayer) {
            TeamMgr.shared.changeTeamLeader(player, toPlayer, player.teamid, data.type);
        }
    }

    //接收客户端发来的 切磋
    c2s_exchange_views(data: any) {
        let player = PlayerMgr.shared.getLikePlayer(this.accountid);
        let t = Date.now();
        if (t - player.lastExchangeViewsTime < 15 * 1000) {
            player.send('s2c_notice', {
                strRichText: '不可频繁请求,请15秒后再次发起切磋！'
            });
            return;
        }
        let toplayer = PlayerMgr.shared.getPlayerByRoleId(data.troleid);
        if (toplayer) {
            toplayer.send('s2c_exchange_views', {
                roleid: player.roleid,
            });
        }
        player.send('s2c_notice', {
            strRichText: '切磋请求发送成功,请等待对方同意！'
        });
        player.lastExchangeViewsTime = t;
    }

    c2s_transfer_team_requst(data: any) {
        let toplayer = PlayerMgr.shared.getPlayerByRoleId(data.toid);
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!toplayer) {
            console.warn(`$警告:组队邀请玩家[${data.toid}]找不到`);
            return;
        }
        if (!player) {
            console.warn(`$警告:组队请求玩家[${this.roleId}]找不到`);
            return;
        }

        if (toplayer.teamid != player.teamid) {
            return;
        }
        toplayer.send('s2c_transfer_team_requst', {
            roleid: player.roleid,
        });
    }

    c2s_team_list(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            TeamMgr.shared.getTeamList(player, data.type);
        }
    }

    //发布招募
    c2s_issue_recruit(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            TeamMgr.shared.issueRecruit(player, data);
        }
    }

    //组队大厅
    c2s_hall_list(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            TeamMgr.shared.getTeamList(player, data.type);
        }
    }

    c2s_team_requeslist(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player && player.isleader) {
            TeamMgr.shared.getRequestList(player, player.teamid);
        }
    }

    c2s_operteam(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        let dealp = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player && dealp && player.teamid == data.teamid && player.isleader) {
            TeamMgr.shared.dealRequest(dealp, data);
            TeamMgr.shared.getRequestList(player, data.teamid);
        }
    }

    c2s_aoi_move(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            player.playerMove(data);
        }
    }

    c2s_aoi_stop(data: any) {
        let player: Player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            player.playerStop(data);
        }
    }

    c2s_player_upskill(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            player.updateSkill(data);
        }
    }

    c2s_player_addpoint(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.addCustomPoint(data);
        }
    }

    c2s_xiulian_point(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.addXiulianPoint(data);
        }
    }

    c2s_xiulian_upgrade(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.xiulianUpgrade(data);
        }
    }

    // scale 0 世界 1 队伍 2 帮派
    c2s_game_chat(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player == null) {
            return;
        }
        //判断是否开通发言
        if (GameConf.speak) {
            let msg = data.msg;
            let chargeTotal = ChargeSum.shared.getPlayerChargeSum(player.roleid);
            if (player.gmlevel <= 0) {
                if (player.GetFlag(GameUtil.EPlayerFlag.EBanSpeak) == 1) {
                    player.send('s2c_notice', {
                        strRichText: '你处于禁言状态'
                    });
                    return;
                }
            }
            for (let i = 0; i < GameUtil.limitWordList.length; i++) {
                const fword = GameUtil.limitWordList[i];
                if (msg.indexOf(fword) != -1) {
                    msg = msg.replace(new RegExp(fword, 'g'), '*');
                }
            }
            let canBroadcast = GameUtil.checkLimitWord(msg);

            if (player.gmlevel == 100 && msg == "逐鹿") {
                SatAssembly.shared.satReadyOpen();
                return;
            } else if (player.gmlevel == 100 && msg == "结束逐鹿") {
                SatAssembly.shared.close();
            }
            if (player.gmlevel == 100 && msg == "帮战") {
                FactionWar.shared.satReadyOpen();
                return;
            } else if (player.gmlevel == 100 && msg == "结束帮战") {
                FactionWar.shared.close();
            }
            data.msg = msg;
            data.teamid = player.teamid;
            data.name = player.name;
            data.resid = player.resid;
            data.roleid = player.roleid;
            data.onlyid = player.onlyid;
            data.voice = new Uint8Array(data.voice);
            data.relive = player.relive;
            data.chargesum = ChargeSum.shared.getPlayerChargeSum(player.roleid);
            data.portrait = SpecialEffect.shared.getPortraitByRoleid(player.roleid);
            data.level = player.level;
            data.bangname = player.bangname;
            // 检测清理背包
            player.clear_bag(msg);
            // 两条信息相同 不广播
            if (player.lastWorldChatStr == msg) {
                canBroadcast = false;
            }
            if (!canBroadcast) {
                player.send('s2c_game_chat', data);
                return;
            }
            if (data.scale == Channel.FACTION) {
                if (player.bangid != null && player.bangid != 0) {
                    let bang = BangMgr.shared.getBang(player.bangid);
                    if (bang) {
                        if (!GameConf.isBeta) {
                            if (player.level < GameUtil.limitWorldChatLevel || chargeTotal < GameUtil.limitBangChatCharge) {
                                let msg = `帮派聊天需要等级达到${GameUtil.limitWorldChatLevel}级并且累计充值${GameUtil.limitWorldChatCharge}元`;
                                player.send('s2c_notice', {
                                    strRichText: msg
                                });
                                return;
                            }
                        }
                        // CXF 通讯记录
                        SKCxfUtil.getCxfRecordMsg({
                            roleId: this.roleId,
                            roleName: this.roleName,
                            msg: msg,
                            type: Channel.FACTION,
                            zoneSerial: GameUtil.serverId
                        })
                        bang.broadcast('s2c_game_chat', data);
                    } else {
                        player.send('s2c_notice', {
                            strRichText: '请先加入帮派'
                        });
                    }
                }
            } else if (data.scale == Channel.TEAM) {
                if (player.teamid == 0) {
                    player.send('s2c_notice', {
                        strRichText: '请先加入队伍'
                    });
                    return;
                }
                if (chargeTotal < GameUtil.limitBangChatCharge) {
                    if (!GameConf.isBeta) {
                        let msg = `队天聊天需要累计充值${GameUtil.limitWorldChatCharge}元`;
                        player.send('s2c_notice', {
                            strRichText: msg
                        });
                        return;
                    }
                }
                let roleList = TeamMgr.shared.getTeamPlayer(player.teamid);
                // CXF 通讯记录
                SKCxfUtil.getCxfRecordMsg({
                    roleId: this.roleId,
                    roleName: this.roleName,
                    msg: msg,
                    type: Channel.TEAM,
                    zoneSerial: GameUtil.serverId
                })
                for (let p of roleList) {
                    p.send('s2c_game_chat', data);
                }
            } else {
                let t = Date.now();
                if (t - player.lastWorldChatTime < 10 * 1000) {
                    player.send('s2c_notice', {
                        strRichText: '聊天间隔不足10秒'
                    });
                    return;
                }
                if (!GameConf.isBeta) {
                    if (player.level < GameUtil.limitWorldChatLevel || chargeTotal < GameUtil.limitWorldChatCharge) {
                        let msg = `世界聊天需要等级达到${GameUtil.limitWorldChatLevel}级并且累计充值${GameUtil.limitWorldChatCharge}元`;
                        player.send('s2c_notice', {
                            strRichText: msg
                        });
                        return;
                    }
                }
                player.lastWorldChatTime = t;
                let rcost = player.CostFee(0, 3000, '世界聊天');
                if (rcost != '') {
                    player.send('s2c_notice', {
                        strRichText: rcost + '，发送失败'
                    });
                    return;
                }
                // CXF 通讯记录
                SKCxfUtil.getCxfRecordMsg({
                    roleId: this.roleId,
                    roleName: this.roleName,
                    msg: msg,
                    type: Channel.WORLD,
                    zoneSerial: GameUtil.serverId
                })
                // 检测礼包码
                // player.checkExchange(msg);
                data.msg = SKDataUtil.filter(data.msg);
                player.lastWorldChatStr = data.msg;
                PlayerMgr.shared.broadcast('s2c_game_chat', data);
            }
        } else {
            player.send_notice("全服禁言中！");
        }

    }

    c2s_get_friends(data?: any) {
        let friendlist = [];
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            let list = player.friendList;
            for (const key in list) {
                if (list.hasOwnProperty(key)) {
                    const pitem = list[key];
                    let friend: any = {
                        roleid: key, //  info.roleid,
                        name: pitem.name, //  info.name,
                        resid: pitem.resid, //  info.resid,
                        relive: 0, //  info.relive,
                        level: -1, //  info.level,
                        race: 0, //  info.race,
                        sex: 0, //  info.sex,
                        state: 1,
                        online: 0,
                        portrait: 0,
                        teamid: 0
                    };
                    let roleId = SKDataUtil.numberBy(key);
                    let target = PlayerMgr.shared.getPlayerByRoleId(roleId);
                    if (target) {
                        friend.name = target.name;
                        friend.level = target.level;
                        friend.relive = target.relive;
                        friend.race = target.race;
                        friend.sex = target.sex;
                        friend.online = (target.offline ? 0 : 1);
                        friend.portrait = SpecialEffect.shared.getPortraitByRoleid(target.roleid)
                        friend.teamid = target.teamid
                        player.updateFriend(friend);
                    }
                    friendlist.push(friend);
                }
            }
            let alist = player.applyFriendList;
            for (let pid in alist) {
                if (alist.hasOwnProperty(pid)) {
                    let pitem = alist[pid];
                    pitem.state = 0;
                    friendlist.push(pitem)
                }
            }
        }

        this.send('s2c_friends_info', {
            list: friendlist,
        });
    }

    c2s_update_friends(data: any) {
        //operation 0：删除 1：同意 2：拒绝 3：全部同意 4：全部拒绝
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player == null) {
            return;
        }
        if (data.operation == 0) {
            delete player.applyFriendList[data.roleid];
            delete player.friendList[data.roleid];
            let target = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
            if (target) {
                delete target.applyFriendList[player.roleid];
                delete target.friendList[player.roleid];
            }
        }
        if (data.operation == 1 || data.operation == 2) {
            if (data.operation == 1) {
                if (player.getFriendNum() > 50) {
                    this.send('s2c_notice', {
                        strRichText: '好友数已达上线，无法添加'
                    });
                    return;
                }
                let info = player.applyFriendList[data.roleid];
                let target = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
                if (target && info) {
                    player.friendList[info.roleid] = {
                        roleid: info.roleid, //  info.roleid,
                        name: info.name, //  info.name,
                        resid: info.resid, //  info.resid,
                        portrait: SpecialEffect.shared.getPortraitByRoleid(target.roleid)
                    };
                    target.friendList[player.roleid] = {
                        roleid: player.roleid, //  info.roleid,
                        name: player.name, //  info.name,
                        resid: player.resid, //  info.resid,
                        portrait: SpecialEffect.shared.getPortraitByRoleid(player.roleid)
                    };
                }
            }
            delete player.applyFriendList[data.roleid];
        }
        if (data.operation == 3) {
            let applynum = 0;
            for (const pid in player.applyFriendList) {
                if (player.applyFriendList.hasOwnProperty(pid)) {
                    // const element = player.applyFriendList[pid];
                    applynum++;
                }
            }
            if (player.getFriendNum() + applynum >= 50) {
                this.send('s2c_notice', {
                    strRichText: '申请人数超过上限，无法全部通过'
                });
                return;
            }
            for (const key in player.applyFriendList) {
                if (player.applyFriendList.hasOwnProperty(key)) {
                    let roleId = SKDataUtil.numberBy(key);
                    let target = PlayerMgr.shared.getPlayerByRoleId(roleId);
                    if (target) {
                        player.friendList[target.roleid] = {
                            roleid: target.roleid, //  info.roleid,
                            name: target.name, //  info.name,
                            resid: target.resid, //  info.resid,
                            portrait: SpecialEffect.shared.getPortraitByRoleid(target.roleid)
                        };
                        target.friendList[player.roleid] = {
                            roleid: player.roleid, //  info.roleid,
                            name: player.name, //  info.name,
                            resid: player.resid, //  info.resid,
                            portrait: SpecialEffect.shared.getPortraitByRoleid(player.roleid)
                        };
                    }
                }
            }
            player.applyFriendList = {};
        }
        if (data.operation == 4) {
            player.applyFriendList = {};
        }
        this.c2s_get_friends();
    }

    c2s_search_friends(data: any) {
        if (data.data == null || data.data == '') {
            return;
        }

        let list = PlayerMgr.shared.getLikePlayer(data.data);
        let rlist = [];
        while (list.length > 6) {
            let r = GameUtil.random(0, list.length - 1);
            list.splice(r, 1);
        }

        for (const player of list) {
            rlist.push({
                roleid: player.roleid,
                name: player.name,
                resid: player.resid,
                level: player.level,
                relive: player.relive,
                race: player.race,
                sex: player.sex,
            });
        }
        this.send('s2c_search_friends', {
            list: rlist,
        })
    }

    c2s_add_friend(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            if (player.getFriendNum() >= 50) {
                this.send('s2c_notice', {
                    strRichText: '好友数已达上限，无法添加好友'
                });
                return;
            }
        }
        if (data.roleid == this.roleId) {
            this.send('s2c_notice', {
                strRichText: '不能添加自己为好友'
            });
            return;
        }
        let target = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (target) {
            if (target.getFriendNum() >= 50) {
                this.send('s2c_notice', {
                    strRichText: '申请失败，对方好友数已达上限'
                });
                return;
            }
            if (target.friendList[data.roleid] != null) {
                this.send('s2c_notice', {
                    strRichText: '申请失败，已经是好友或已申请'
                });
                return;
            }
            if (target.applyFriendList[data.roleid] != null) {
                this.send('s2c_notice', {
                    strRichText: '申请失败，已经是好友或已申请'
                });
                return;
            }
        }
        if (player && target) {
            target.applyFriendList[player.roleid] = {
                roleid: player.roleid,
                name: player.name,
                resid: player.resid,
                level: player.level,
                relive: player.relive,
                race: player.race,
                sex: player.race,
                online: !player.offline
            }
            this.send('s2c_notice', {
                strRichText: '已申请，等待对方同意'
            });
            target.send('s2c_friend_apply');
        } else {
            this.send('s2c_notice', {
                strRichText: '对方不在线'
            });
        }
    }

    c2s_friend_chat(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player == null) {
            return;
        }
        if (player.GetFlag(GameUtil.EPlayerFlag.EBanSpeak) == 1) {
            player.send('s2c_notice', {
                strRichText: '你处于禁言状态'
            });
            return;
        }
        let msg = data.msg;
        for (let i = 0; i < GameUtil.limitWordList.length; i++) {
            const fword = GameUtil.limitWordList[i];
            if (msg.indexOf(fword) != -1) {
                msg = msg.replace(new RegExp(fword, 'g'), '*');
            }
        }
        let canBroadcast = true;
        let numcount = 0;
        for (let k = 0; k < msg.length; k++) {
            const msgchar = msg[k];
            if (GameUtil.numchar.indexOf(msgchar) != -1) {
                numcount++
                if (numcount >= 7) {
                    canBroadcast = false;
                    break;
                }
            }
        }
        for (let i = 0; i < GameUtil.limitBroadcastList.length; i++) {
            const fword = GameUtil.limitBroadcastList[i];
            if (msg.indexOf(fword) != -1) {
                canBroadcast = false;
                break;
            }
        }
        if (canBroadcast) {
            let friend = PlayerMgr.shared.getPlayerByRoleId(data.toid);
            if (friend) {
                friend.send('s2c_friend_chat', data);
            }
        }
    }

    // 邮件
    c2s_mail_list(data: any) {
        let player: Player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player == null) {
            return;
        }
        player.mailList.check();
        player.mailList.getMailList();
    }

    c2s_mail_action(data: any) {
        let player: Player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player == null) {
            return;
        }
        player.mailList.runAction(data);
    }

    QueryPartner(nRoleID: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player == null) {
            return;
        }
        let mapPartner = player.partnerMgr.mapPartner;
        let vecJson = [];
        for (var it in mapPartner) {
            let strJson = GameUtil.getPartnerJson(mapPartner[it]);
            vecJson.push({
                strJson: strJson
            });
        }
        this.send('s2c_partner_list', {
            vecPartner: vecJson,
            strJsonPos: SKDataUtil.toJson(player.partnerMgr.vecChuZhan, "{}")
        });
    }

    // 伙伴转生
    partnerRelive(data: any) {
        if (data == null || data.nPartnerID == null)
            return;

        let nPartnerID = data.nPartnerID;
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player == null) {
            return;
        }
        let partner = player.partnerMgr.GetPartner(nPartnerID);
        if (partner == null) {
            return;
        }
        let info = partner.doRelive();
        player.send('s2c_npc_notice', {
            nNpcConfigID: 10094,
            strRichText: info == '' ? '伙伴转生成功' : info
        });
        player.partnerMgr.SendPartnerInfoToClient(nPartnerID);
    }

    ChangePartnerState(data: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer)
            return;

        pPlayer.partnerMgr.ChangeChuZhanPos(data.nPos, data.nPartnerID);
        if (pPlayer.teamid > 0 && pPlayer.isleader) {
            TeamMgr.shared.changePartner(pPlayer.teamid, pPlayer);
        }

        pPlayer.syncSchemePartner();
    }

    getTeamInfo(data: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer)
            return;
        if (pPlayer.teamid > 0) {
            TeamMgr.shared.changePartner(pPlayer.teamid, pPlayer);
        }
    }

    PartnerExchangeExp(data: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(data.nRoleID);
        if (null == pPlayer)
            return;
        if (data.nCostWhat == 0) {
            return;
        }
        if (data.nCostWhat == 1) {
            let strErr = pPlayer.CostFee(0, 3000000, '传功');
            if (strErr != '') {
                pPlayer.send('s2c_notice', {
                    strRichText: strErr
                });
                return;
            }
        }
        let pPartnerA: any = pPlayer.partnerMgr.GetPartner(data.nPartnerA);
        let pPartnerB: any = pPlayer.partnerMgr.GetPartner(data.nPartnerB);
        if (null == pPartnerA || null == pPartnerB)
            return;

        for (let key of ['relive', 'level', 'exp']) {
            let nTmp = pPartnerA[key];
            pPartnerA[key] = pPartnerB[key];
            pPartnerB[key] = nTmp;
        }

        this.QueryPartner(data.nRoleID);
        this.send('s2c_partner_exchange_exp_ok', {
            nPartnerA: data.nPartnerA,
            nAExp: pPartnerA.exp,
            nPartnerB: data.nPartnerB,
            nBExp: pPartnerB.exp
        });
    }


    QueryOther(nRoleID: any) {
        let sql = `select roleid,resid,level,relive,name from qy_role where roleid = ${nRoleID}`;
        DB.query(sql, (ret: any, rows: any) => {
            let stData = null;
            for (let i = 0; i < rows.length; i++) {
                stData = {
                    nRoleID: rows[i].roleid,
                    nResID: rows[i].resid,
                    nLevel: rows[i].level,
                    nRelive: rows[i].relive,
                    strName: rows[i].name,
                    strBangName: '',
                };
                break;
            }
            this.send('c2s_other_info', stData);
        });
    }

    QueryRoleTask() {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer)
            return;

        pPlayer.getTaskMgr().updateTaskStateToClient();
    }

    PlayerChallengeNpc(nOnlyID: any, nConfigID: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer)
            return;
        let pNpc = NpcMgr.shared.findNpc(nOnlyID);
        if (null == pNpc)
            return;
        if (World.shared.starMgr.IsStar(nOnlyID)) {
            let strErr = World.shared.starMgr.ApplyChallenge(nOnlyID, pPlayer.roleid, pPlayer.getWorldStar());
            if (strErr == 0) {
                pPlayer.send('s2c_npc_notice', {
                    nNpcConfigID: pNpc.configid,
                    strRichText: '报名成功，请等待'
                });
                pPlayer.send('s2c_star_waiting', {});
            } else {
                let str = '你来晚了，下次早点来哦';
                if (strErr == 3) {
                    str = '请先击杀低级地煞星！';
                }
                pPlayer.send('s2c_npc_notice', {
                    nNpcConfigID: pNpc.configid,
                    strRichText: str
                });
                World.shared.starMgr;
            }
        }// 天元盛典
        else if (DWorld.shared.starMgr.IsStar(nOnlyID)) {
            let strErr = DWorld.shared.starMgr.ApplyChallenge(nOnlyID, pPlayer.roleid, pPlayer.getWorldStar());
            if (strErr == 0) {
                pPlayer.send('s2c_npc_notice', {
                    nNpcConfigID: pNpc.configid,
                    strRichText: '报名成功，请等待'
                });
                pPlayer.send('s2c_star_waiting', {});
            } else {
                let str = '你来晚了，下次早点来哦';
                if (strErr == 3) {
                    str = '请先击杀任务怪！';
                }
                pPlayer.send('s2c_npc_notice', {
                    nNpcConfigID: pNpc.configid,
                    strRichText: str
                });
                DWorld.shared.starMgr;
            }
        }
        // 逐鹿恶鬼
        else if (World.shared.magicWorldMgr.IsMagic(nOnlyID)) {

            let team = TeamMgr.shared.getTeamInfo(pPlayer.teamid);

            if (team == null || team.playerlist.length < 3) {
                pPlayer.send('s2c_npc_notice', {
                    nNpcConfigID: pNpc.configid,
                    strRichText: "必须3人以上组队才可挑战"
                });
                return;
            }
            let strErr = World.shared.magicWorldMgr.ApplyChallenge(nOnlyID, pPlayer.roleid);
            if (strErr == 0) {
                pPlayer.send('s2c_npc_notice', {
                    nNpcConfigID: pNpc.configid,
                    strRichText: '报名成功，请等待'
                });
                pPlayer.send('s2c_star_waiting', {});
            } else {
                let str = '你来晚了，下次早点来哦';
                pPlayer.send('s2c_npc_notice', {
                    nNpcConfigID: pNpc.configid,
                    strRichText: str
                });
                World.shared.magicWorldMgr;
            }
        }
        else if (World.shared.pirateMgr.IsPirate(nOnlyID)) {

            let team = TeamMgr.shared.getTeamInfo(pPlayer.teamid);
            if (team == null || team.playerlist.length < 3) {
                pPlayer.send('s2c_npc_notice', {
                    nNpcConfigID: pNpc.configid,
                    strRichText: "你还是凑齐3个人再来孝敬大爷我吧！"
                });
                return;
            }
            for (let i = 0; i < team.playerlist.length; i++) {
                const mem = team.playerlist[i];
                if (mem.level < 40) {
                    pPlayer.send('s2c_npc_notice', {
                        nNpcConfigID: pNpc.configid,
                        strRichText: `队伍中玩家${mem.name}等级不符合条件！`
                    });
                    return;
                }
            }
            let strErr = World.shared.pirateMgr.ApplyChallenge(nOnlyID, pPlayer.roleid);
            if (strErr == 0) {
                pPlayer.send('s2c_npc_notice', {
                    nNpcConfigID: pNpc.configid,
                    strRichText: '报名成功，请等待'
                });
                pPlayer.send('s2c_star_waiting', {});
            } else {
                let str = '你来晚了，下次早点来哦';
                pPlayer.send('s2c_npc_notice', {
                    nNpcConfigID: pNpc.configid,
                    strRichText: str
                });
                World.shared.pirateMgr;
            }
        }//金蟾送福
        else if (JIngChanSongFuMgr.shared.IsJInchan(nOnlyID)) {
            let strErr = JIngChanSongFuMgr.shared.ApplyChallenge(nOnlyID, pPlayer.roleid);
            if (strErr == 0) {
                pPlayer.send('s2c_npc_notice', {
                    nNpcConfigID: pNpc.configid,
                    strRichText: '报名成功，请等待'
                });
                pPlayer.send('s2c_star_waiting', {});
            } else {
                let str = '你来晚了，下次早点来哦';
                pPlayer.send('s2c_npc_notice', {
                    nNpcConfigID: pNpc.configid,
                    strRichText: str
                });

            }
        } else {
            this.TrigleNpcBomb(nConfigID, nOnlyID);
        }
    }

    PlayerEnterBattle(nGroupID: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer)
            return;

        let battle = pPlayer.monsterBattle(nGroupID);
    }

    TrigleNpcBomb(nNpcConfigID: any, nNpcOnlyID: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer)
            return;

        if (pPlayer.teamid > 0 && pPlayer.isleader == false)
            return;

        let stConfig = NpcConfigMgr.shared.getConfig(nNpcConfigID);
        let battle = pPlayer.monsterBattle(stConfig.monster_group);
        if (battle != null)
            battle.source = nNpcOnlyID;
    }

    // 开始组任务
    startGroupTask(npcOnlyId: number, taskGroup: number) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player == null) {
            SKLogger.debug(`开始组任务:玩家[${this.roleId}:${this.roleName}]找不到!`);
            return;
        }
        let npc: Npc = NpcMgr.shared.findNpc(npcOnlyId);
        if (npc == null) {
            SKLogger.debug(`开始组任务:玩家[${this.roleId}:${this.roleName}]找不到NPC[${npcOnlyId}]!`);
            return;
        }
        let info: string = player.getTaskMgr().startGroupTask(taskGroup);
        if (info.length > 0) {
            SKLogger.debug(`开始组任务:玩家[${this.roleId}:${this.roleName}]信息[${info}]!`);
            player.send('s2c_npc_notice', {
                nNpcConfigID: npc.configid,
                strRichText: info
            });
        }
    }

    c2s_player_shutup(nTargetRoleID: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer)
            return;

        GMMgr.shared.LetPlayerShutUp(pPlayer, nTargetRoleID);
    }

    c2s_player_speak(nTargetRoleID: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer)
            return;

        GMMgr.shared.letPlayerSpeak(pPlayer, nTargetRoleID);
    }

    KickOffPlayer(nTargetRoleID: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer)
            return;
        GMMgr.shared.FreezePlayer(pPlayer, nTargetRoleID);
    }

    FreezePlayerIP(nTargetRoleID: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer)
            return;
        GMMgr.shared.FreezePlayerIP(pPlayer, nTargetRoleID);
    }

    FreezePlayerMAC(nTargetRoleID: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer)
            return;
        GMMgr.shared.FreezePlayerMAC(pPlayer, nTargetRoleID);
    }

    TaskReset() {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer)
            return;

        if (0) {
            pPlayer.initTaskMgr('{}');
            pPlayer.getTaskMgr().updateTaskStateToClient();
        }
    }

    AbortTask(data: any) {
        if (null == data || data.nTaskID == null)
            return;

        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (pPlayer == null)
            return;

        let pTaskInfo = TaskConfigMgr.shared.getTaskConf(data.nTaskID);
        if (null == pTaskInfo)
            return;

        if (TaskConfigMgr.shared.isTeamTask(data.nTaskID)) {
            if (pPlayer.isleader == false)
                return;

            let vecMember = TeamMgr.shared.getTeamPlayer(pPlayer.teamid);

            for (var it in vecMember) {
                let pMember = vecMember[it];
                if (null == pMember)
                    continue;

                pMember.getTaskMgr().abortTask(data.nTaskID);
            }
        } else {
            pPlayer.getTaskMgr().abortTask(data.nTaskID);
        }

    }

    InceptFuBenTask(nNpcOnlyID: any, nTaskID: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!pPlayer)
            return;

        let strErr = pPlayer.getTaskMgr().CheckAndInceptFuBenTask(nTaskID);
        if (strErr != '' && strErr != 'syserr') {
            if (nNpcOnlyID > 0) {
                let pNpc = NpcMgr.shared.findNpc(nNpcOnlyID);
                if (null == pNpc) {
                    return;
                }
                pPlayer.send('s2c_npc_notice', {
                    nNpcConfigID: pNpc.configid,
                    strRichText: strErr
                });
            } else {
                pPlayer.send('s2c_notice', {
                    strRichText: strErr
                });
            }
        }
    }

    // NPC对话事件
    onTaskTalkNpc(taskId: number, step: number, npcConfId: number, npcOnlyId: number) {
        let player: Player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        let task = TaskConfigMgr.shared.getTaskConf(taskId);
        if (player == null) {
            SKLogger.debug(`NPC对话:找不到玩家!`);
            return;
        }
        if (player.taskMgr == null) {
            SKLogger.debug(`NPC对话:玩家[${player.roleid}:${player.name}]无任务管理器`);
            return;
        }
        if (player.teamid > 0 && player.isleader == false) {
            SKLogger.debug(`NPC对话:玩家[${player.roleid}:${player.name}]是队员跳过!`);
            return;
        }
        let stepConf: EventBase = TaskConfigMgr.shared.getTaskStepInfo(taskId, step);
        if (stepConf == null) {
            SKLogger.debug(`NPC对话:玩家[${player.roleid}:${player.name}]找不到任务[${taskId}:${step}]步骤配置!`);
            return;
        }
        let stepState: EventStateBase = player.getTaskMgr().getTaskStepState(taskId, step);
        if (stepState == null) {
            SKLogger.debug(`NPC对话:玩家[${player.roleid}:${player.name}]找不到任务[${taskId}:${step}]状态信息!`);
            return;
        }
        if (stepConf.nEventType == EEventType.PLAYER_TALK_NPC) {
            let temp: TalkEventState = <TalkEventState>stepState;
            player.getTaskMgr().onGameEvent(EEventType.PLAYER_TALK_NPC, {
                nTaskID: taskId,
                nStep: step
            });
            NpcMgr.shared.CheckAndDeleteNpc(npcOnlyId, player);
            return;
        }
        if (stepConf.nEventType == EEventType.PLAYER_KILL_NPC) {
            let temp: KillDynamicNpcState = <KillDynamicNpcState>stepState;
            let nGroupID = 0;
            for (let item of temp.vecRemainNpc) {
                if (item.nOnlyID != npcOnlyId) {
                    continue;
                }
                let npcConf: any = NpcConfigMgr.shared.getConfig(npcConfId);
                if (npcConf == null) {
                    continue;
                }
                nGroupID = npcConf.monster_group;
                let battle = player.monsterBattle(nGroupID, task.nTaskGrop);
                if (battle != null) {
                    battle.source = npcOnlyId;
                }
                return;
            }
            let npcConf: any = NpcConfigMgr.shared.getConfig(npcConfId);
            SKLogger.debug(`NPC对话事件:[玩家${player.roleid}:${player.name}]找不到任务[${taskId}]NPC[${npcConfId}${npcConf.name}]杀死!`);
            return;
        }
        if (stepConf.nEventType == EEventType.PLAYER_GIVE_NPC_ITEM) {
            let temp = <GiveNpcItem>stepConf;
            if (player.getBagItemNum(temp.nItemID) < temp.nNum) {
                SKLogger.debug(`[玩家:${this.roleId}:${this.roleName}交付道具数量少于${temp.nNum}个]`);
                return;
            }
            player.addItem(temp.nItemID, -temp.nNum, true, '任务上交');
            player.getTaskMgr().onGameEvent(EEventType.PLAYER_GIVE_NPC_ITEM, 0);
            return;
        }
    }

    OnRoleActNpc(nOnlyID: any, nNpcConfigID: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer)
            return;

        pPlayer.getTaskMgr().onGameEvent(EEventType.PLAYER_GATHER_NPC, nOnlyID);
        NpcMgr.shared.CheckAndDeleteNpc(nOnlyID, pPlayer);
    }

    OnRoleAction(stData: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer)
            return;

        pPlayer.getTaskMgr().onGameEvent(EEventType.PLAYER_DO_ACITION, stData);
    }

    // 获得排行榜数据
    getRanking(data: any) {

        let vecData = null;
        switch (data.nByWhat) {
            case 0: {
                vecData = PaiHangMgr.shared.getLevelRank();
            }
                break;
            case 1: {
                vecData = PaiHangMgr.shared.getMoneyRank();
            }
                break;
            case 2: {
                vecData = PaiHangMgr.shared.getBangRank();
            }
                break;
            case 3: {
                vecData = PaiHangMgr.shared.getShuiluRank();
            }
                break;
            case 4: {
                vecData = PaiHangMgr.shared.getJingJiRank();
            }
                break;
            case 5: {
                vecData = PaiHangMgr.shared.getEquipRank(SKDataUtil.jsonBy(data.object));
            }
                break;
            case 6: {
                vecData = PaiHangMgr.shared.getMurderRank();
            }
                break;
            case 7: {
                vecData = PaiHangMgr.shared.getEquipRank2(SKDataUtil.jsonBy(data.object));
            }
                break;
        }
        if (vecData != null) {
            let player = PlayerMgr.shared.getPlayerByRoleId(data.nRoleid);
            if (player) {
                let greater: any = [];
                let agreater: any = [];
                let jplayer = PaiHangMgr.shared.getJingjiRank(player.roleid);
                if (jplayer.ranking > 5) {
                    for (let i = 0; i < vecData.length; i++) {
                        let brole = vecData[i];
                        if (brole[7] < jplayer.ranking && brole[7] > 5) {
                            greater.push(vecData[i]);
                        }
                        if (jplayer.ranking < 21 && brole[7] <= jplayer.ranking && brole[7] > 5) {
                            agreater.push(vecData[i]);
                        }
                    }
                    let frist = vecData.slice(0, 5);
                    if (jplayer.ranking < 21) {
                        vecData = PaiHangMgr.shared.topList(agreater, 5);
                    } else {
                        vecData = PaiHangMgr.shared.topList(greater, 5);
                    }
                    vecData.splice(0, 5);
                    vecData = frist.concat(vecData);
                } else {
                    vecData = PaiHangMgr.shared.topList(vecData, 5);
                }
                this.send('s2c_paihang', {
                    rankKind: data.nByWhat,
                    vecRow: SKDataUtil.toJson(vecData, "{}"),//排行榜集合
                    brole: SKDataUtil.toJson(player.toObj(), "{}"),//个人信息
                });
            } else {
                this.send('s2c_paihang', {
                    rankKind: data.nByWhat,
                    vecRow: SKDataUtil.toJson(vecData, "{}")
                });
            }

        }
    }


    QueryItemGoods(data: any) {
        let vecGoods = [];

        for (let it in Shop.shared.mapItem) {
            let stItem = Shop.shared.mapItem[it];

            if (stItem.nKind != data.nKind)
                continue;

            if (data.nConfigID > 0 && stItem.nConfigID != data.nConfigID)
                continue;

            if (stItem.nCnt <= 0)
                continue;

            let stGoods = {
                nID: stItem.nID,
                nConfigID: stItem.nConfigID,
                nPrice: stItem.nPrice,
                nCnt: stItem.nCnt,
                nTime: stItem.nAddTime
            };

            vecGoods.push(stGoods);
        }

        this.send('s2c_goods', {
            vecGoods: vecGoods
        })
    }

    QueryEquipGoods(data: any) {

        let vecGoods = [];

        for (let it in Shop.shared.mapItem) {
            let stItem = Shop.shared.mapItem[it];

            if (stItem.nKind != 1)
                continue;

            if (data.nPart > 0 && stItem.nSubKind != data.nPart)
                continue;

            if (stItem.nCnt <= 0)
                continue;

            let stGoods = {
                nID: stItem.nID,
                nConfigID: stItem.nConfigID,
                nPrice: stItem.nPrice,
                nCnt: stItem.nCnt,
                nTime: stItem.nAddTime
            };

            vecGoods.push(stGoods);
        }

        this.send('s2c_goods', {
            vecGoods: vecGoods
        })
    }

    QueryAndSendRolsGoods(nRoleID: any) {

        let vecGoods = [];

        for (let it in Shop.shared.mapItem) {
            let stItem = Shop.shared.mapItem[it];

            if (stItem.nSeller != this.accountid)
                continue;

            let stGoods = {
                nID: stItem.nID,
                nConfigID: stItem.nConfigID,
                nPrice: stItem.nPrice,
                nCnt: stItem.nCnt,
                nTime: stItem.nAddTime
            };

            vecGoods.push(stGoods);
        }

        this.send('s2c_roles_goods', {
            vecGoods: vecGoods
        })
    }

    AskDailyInfo() {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!pPlayer) {
            return;
        }
        pPlayer.getTaskMgr().SendDailyActive();

    }

    TakeActivePrize(nIndex: number) {
        let pPlayer: Player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer)
            return;
        if (nIndex < 0 || nIndex > 5)
            return;
        if (pPlayer.getTaskMgr().szBeenTake[nIndex] == 1)
            return;
        let strPrize = pPlayer.getTaskMgr().szActivePrize[nIndex];
        if (nIndex == 5) {
            pPlayer.doublecnt += 60;
            DB.updateDoublePoint({ doublecnt: pPlayer.doublecnt, unget_doublecnt: pPlayer.unget_doublecnt, roleid: pPlayer.roleid })
            pPlayer.send_notice("满活跃度赠60点双倍点数")
        }
        let vecTmp = strPrize.split(",");
        pPlayer.addItem(parseInt(vecTmp[0]), parseInt(vecTmp[1]), true, '活跃度奖励');
        pPlayer.getTaskMgr().szBeenTake[nIndex] = 1;
        this.AskDailyInfo();
    }

    AddGoods(data: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer)
            return;

        pPlayer.send('s2c_notice', {
            strRichText: '物品暂时无法出售'
        });
        return;

        if (pPlayer.bag_list.hasOwnProperty(data.nConfigID) == false)
            return;

        if (Shop.shared.IsIteamCanSell(data.nConfigID) == false) {
            pPlayer.send('s2c_notice', {
                strRichText: '此物品不可出售'
            });
            return;
        }

        if (pPlayer.bag_list[data.nConfigID] < data.nCnt)
            return;

        let stItemInfo = ItemUtil.getItemData(data.nConfigID);
        if (null == stItemInfo)
            return;

        let nRet = pPlayer.addItem(data.nConfigID, -data.nCnt, false, '出售物品');
        if (!nRet)
            return;

        let nID = Shop.shared.GetMaxID() + 1;
        let stShopItem = new ShopItem(nID, data.nConfigID, stItemInfo.type, 0, '', this.accountid, GameUtil.getTime(), data.nPrice, data.nCnt, 0);
        Shop.shared.mapItem[nID] = stShopItem;
        this.QueryAndSendRolsGoods(this.accountid);
    }

    TakeBackGoods(stMsg: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer)
            return;

        let pShopItem = Shop.shared.FindShopItem(stMsg.nID);
        if (null == pShopItem)
            return;

        if (pShopItem.nSeller != this.accountid)
            return;

        let nMoney = pShopItem.nSellCnt * pShopItem.nPrice * 0.9;

        if (pShopItem.nCnt > 0)
            pPlayer.addItem(pShopItem.nConfigID, pShopItem.nCnt, false, '取回出售物品');

        if (pShopItem.nSellCnt > 0)
            pPlayer.addMoney(0, nMoney);


        delete Shop.shared.mapItem[stMsg.nID];
        this.QueryAndSendRolsGoods(this.accountid);

        let strMsg = pShopItem.nSellCnt > 0 ? `取回剩余物品${pShopItem.nCnt},已售部分所得银两${nMoney}` : `取回剩余物品${pShopItem.nCnt}`;
        pPlayer.send('s2c_notice', {
            strRichText: strMsg
        });
    }

    BuyGoods(data: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer)
            return;

        let pShopItem = Shop.shared.FindShopItem(data.nID);
        if (null == pShopItem)
            return;

        if (pShopItem.nCnt < data.nCnt) {
            pPlayer.send('s2c_notice', {
                strRichText: '数量不足'
            });
            return;
        }

        if (pPlayer.money < data.nCnt * pShopItem.nPrice) {
            pPlayer.send('s2c_notice', {
                strRichText: '银两不足'
            });
            return;
        }

        if (pPlayer.getBagItemAllKindNum() >= pPlayer.bagKindNum) {
            pPlayer.send('s2c_notice', {
                strRichText: '背包已满，无法购买'
            });
            return;
        }
        pPlayer.addItem(pShopItem.nConfigID, data.nCnt, false, '摆摊处购买');
        pPlayer.addMoney(0, -data.nCnt * pShopItem.nPrice);

        pShopItem.nCnt -= data.nCnt;
        pShopItem.nSellCnt += data.nCnt;

        pShopItem.nKind == 0 ? this.QueryItemGoods({
            nKind: pShopItem.nKind,
            nItem: 0
        }) : this.QueryEquipGoods({
            nKind: pShopItem.nKind,
            nItem: 0
        });
        pPlayer.send('s2c_notice', {
            strRichText: '购买成功'
        });
    }

    buyFromNpc(npcConfId: any, nItemID: any, nCnt: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer) {
            return;
        }
        if (pPlayer.getBagItemAllKindNum() >= pPlayer.bagKindNum) {
            pPlayer.send('s2c_notice', {
                strRichText: '背包已满，无法购买'
            });
            return;
        }
        let pNpcShop;
        if (npcConfId != 60002) {
            pNpcShop = MallMgr.shared.getNpcShopData(npcConfId);
        } else {
            pNpcShop = ZhenbukuiMgr.shared.getNpcShopData();
        }
        if (pNpcShop == null) {
            return;
        }
        let vecGoods = pNpcShop.goods;
        if (null == vecGoods) {
            return;
        }
        let pGoods = null;
        for (var it in vecGoods) {
            if (vecGoods[it].itemid != nItemID)
                continue;
            pGoods = vecGoods[it];
            break;
        }
        if (pGoods == null) {
            return;
        }
        if (pGoods.quantity != null && pGoods.quantity <= 0) {
            pPlayer.send('s2c_notice', {
                strRichText: '商品已售罄'
            });
            this.updateShopItemQuantity(nItemID, nCnt);
            return;
        }
        if (nCnt <= 0) {
            return;
        }
        if (GameUtil.getDefault(pGoods.type) == 'weapon') {
            this.c2s_creat_equip({
                type: 0,
                roleid: pPlayer.roleid,
                index: 0,
                resid: nItemID
            });
        } else {
            let pItemInfo = ItemUtil.getItemData(nItemID);
            if (pItemInfo == null) {
                return;
            }
            let info = pPlayer.CostFee(pGoods.moneykind, nCnt * pGoods.price, `从Npc购买${nCnt}个${pItemInfo.name}`);
            if (info != '') {
                pPlayer.send('s2c_notice', {
                    strRichText: info
                });
                return;
            }
            if (pGoods.moneykind == 5) {
                let data = { nByWhat: 4, nRoleid: this.roleId };
                this.getRanking(data);
            }
            pPlayer.addItem(nItemID, nCnt, true, '从NPC购买');
        }

        if (npcConfId == 60002) {
            this.updateShopItemQuantity(nItemID, nCnt);
        }
    }

    updateShopItemQuantity(itemId: any, nCnt: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        let netItemInfo = ZhenbukuiMgr.shared.updateShopItem(itemId, nCnt);
        if (netItemInfo.length > 0) {
            if (netItemInfo[0].itemid == itemId) {
                pPlayer.send('s2c_update_shop_info', {
                    nItemID: itemId,
                    quantity: netItemInfo[0].quantity
                });
            }
        }
    }

    BuyMall(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!player) {
            return;
        }
        MallMgr.shared.buyItem(player, data.type, data.mallid, data.mallnum);
    }

    TakeGoodsMoney() {

    }

    // 请求背包数据
    c2s_get_bagitem(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            let params = {
                info: SKDataUtil.toJson(player.bag_list, "{}")
            };
            player.send("s2c_bagitem", params);
        }
    }


    // 获得多宝阁商店列表
    c2s_get_mall(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        MallMgr.shared.sendList(player);
    }

    // 获得积分商店列表
    c2s_integral_mall(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        MallMgr.shared.sendIntegralList(player);
    }

    c2s_ask_relive_list(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player == null) {
            return;
        }
        player.sendReliveList();
    }

    c2s_change_relive_list(data: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer)
            return;
        pPlayer.changeReliveList(data);
    }

    // 请求合成物品
    c2s_compose(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player == null) {
            SKLogger.warn(`合成道具[${data.nFatherItem}]找不到玩家[${this.roleId}]`);
            return;
        }
        let nFatherItem = data.nFatherItem;
        if (!ItemUtil.canSynthesis(nFatherItem)) {
            player.send('s2c_notice', {
                strRichText: `玩家[${player.roleid}:${player.name}]物品[${ItemUtil.getItemName(nFatherItem)}]无法合成`
            });
            return;
        }
        if (data.nNum <= 0) {
            SKLogger.debug(`玩家[${player.roleid}:${player.name}]物品[${data.nFatherItem}]合成数量不能为0个`);
            return;
        }
        let mapNum: any = {};
        let vecSon: any = ItemUtil.getSynthesisItem(nFatherItem);
        for (let key in vecSon) {
            let vecData = vecSon[key].split(':');
            if (vecData.length != 2)
                return;

            let nItem = vecData[0];
            let nNum = vecData[1];
            mapNum[nItem] = GameUtil.getDefault(mapNum[nItem], 0) + nNum * data.nNum;
        }
        for (let key in mapNum) {
            if (player.getBagItemNum(key) < mapNum[key]) {
                player.send('s2c_notice', {
                    strRichText: `所需物品[${data.nFatherItem}]数量不足!`
                });
                return;
            }
        }
        if (player.getBagItemAllKindNum() + 1 >= player.bagKindNum) {
            player.send_notice("背包空间不足,请先扩充背包!")
            player.send('s2c_lottery_info', {
                strJson: ""
            });
            SKLogger.debug(`玩家[${player.roleid}:${player.name}]背包已满`);
            return;
        }
        for (let key in mapNum) {
            player.addItem(SKDataUtil.numberBy(key), SKDataUtil.numberBy(-mapNum[key]), true, `玩家[${player.roleid}:${player.name}]合成物品[${data.nFatherItem}]`);
        }
        player.addItem(nFatherItem, data.nNum, true, `物品[${data.nFatherItem}]合成成功`);
    }

    c2s_ask_lottery_info(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player == null) {
            return;
        }
        if (data.itemId == 50004) {
            if (player.getBagItemNum(50004) <= 0) {
                player.send('s2c_notice', {
                    strRichText: '高级藏宝图不足'
                });
                return;
            }
        } else {
            if (player.getBagItemNum(50023) <= 0) {
                player.send('s2c_notice', {
                    strRichText: '山河社稷图不足'
                });
                return;
            }
        }

        if (player.getBagItemAllKindNum() + 1 >= player.bagKindNum) {
            player.send('s2c_notice', {
                strRichText: '背包已满，无法抽奖！'
            });
            player.send('s2c_lottery_info', {
                strJson: ""
            });
            SKLogger.debug(`玩家[${player.roleid}:${player.name}]背包已满，无法使用宝图`);
            return;
        }
        player.addItem(data.itemId, -1, false, data.itemId == 50004 ? '使用宝图' : '山河社稷图');
        let strJson = data.itemId == 50004 ? LotteryMgr.shared.CreateLotteryBox() : LotteryMgr.shared.CreateLotterySuperBox();
        player.send('s2c_lottery_info', {
            strJson: strJson
        });
    }

    c2s_lottery_go(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == player)
            return;

        let pBox = LotteryMgr.shared.GetBox(data.nID);
        if (null == pBox) {
            player.send('s2c_notice', {
                strRichText: '宝图已失效'
            });
            return;
        }
        let nSelect = pBox.RandSelect()
        let nLen = GameUtil.random(1, 3) * 15 + nSelect;
        player.send('s2c_lottery_result', {
            nSelect: nSelect,
            nLen: nLen
        });
        setTimeout(() => {
            GameUtil.givePlayerPrize(player, pBox.vecItem[nSelect].strItem, parseInt(pBox.vecItem[nSelect].nNum));
            LotteryMgr.shared.DeleteBox(pBox.nBoxID);
        }, 300);
    }

    // 请求幸运转盘
    c2s_ask_dial_info(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player == null) {
            return;
        }
        // 风雨宝箱
        if (data.type == 1) {
            DialMgr.shared.CreateDialBox(player, data.type);
        }
        // 幸运转盘
        else {
            DialMgr.shared.CreateDial(player, data.type, data.genre);
        }

    }

    // 幸运转盘获取到道具发送玩家
    c2s_dial_go(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == player)
            return;
        DialMgr.shared.GetDial(player, data.id, data.type);
    }

    c2s_ask_npc_shop_item(data: any) {
        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (null == pPlayer)
            return;

        let itemList;
        if (data.nNpcConfigID != 60002) {
            if (!MallMgr.shared.checkNpcData(data.nNpcConfigID))
                return;
            let dl = MallMgr.shared.getNpcShopData(data.nNpcConfigID);
            itemList = SKDataUtil.toJson(dl, "{}");
        } else {
            if (!ZhenbukuiMgr.shared.checkNpcData(data.nNpcConfigID))
                return;
            itemList = SKDataUtil.toJson(ZhenbukuiMgr.shared.getNpcShopData(data.nNpcConfigID), "{}");
        }

        if (itemList != null) {
            pPlayer.send('s2c_npc_shop_item', {
                info: itemList
            });
        }
    }

    // 前端使用背包道具
    c2s_use_bagitem(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player == null) {
            SKLogger.warn(`$警告:使用道具,玩家[帐号:${this.accountid}]找不到!`);
            return;
        }
        let itemData = ItemUtil.getItemData(data.itemid);
        if (itemData == null) {
            SKLogger.warn(`$警告:玩家[${player.roleid}:${player.name}}]使用道具[${data.itemid}]找不到`);
            return;
        }
        // 玩家背包里无此道具
        if (!player.bag_list.hasOwnProperty(data.itemid)) {
            player.send_notice(`[color=#ff0000]警告:背包无此[/color][color=#60d566][${itemData.name}][/color][color=#ff0000]道具[/color]`)
            SKLogger.debug(`$警告:玩家[${player.roleid}:${player.name}}]背包无此道具[${data.itemid}]`);
            return;
        }
        // 玩家背包里此道具数量为0
        if (player.bag_list[data.itemid] < 1) {
            SKLogger.warn(`$警告:玩家[${player.roleid}:${player.name}}]道具[${data.itemid}]数量为0`);
            return;
        }
        // 如果是宝箱
        if (BoxMgr.shared.canUseItem(data)) {
            return;
        }
        // 如果使用的是 高级藏宝图 则判断背包是否有足够的空间
        if (data.itemid == 50004) {
            if (player.getBagItemAllKindNum() + 1 >= player.bagKindNum) {
                player.send('s2c_notice', {
                    strRichText: `背包没有足够的空间，无法使用[${itemData.name}]!`
                });
                return;
            }
        }
        // 如果道具有使用效果
        if (itemData.effect == 1) {
            data.operation = 0;
            if (GoodsMgr.shared.useItem(data)) {
                this.c2s_update_bagitem(data);
            }
        } else {
            SKLogger.warn(`$警告:玩家[${player.roleid}:${player.name}}]道具[${data.itemid}]非使用类型`);
        }
    }

    c2s_stop_incense(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.stopIncense();
        }
    }

    c2s_get_lockeritem(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            let params = {
                bag: SKDataUtil.toJson(player.bag_list, "{}"),
                locker: SKDataUtil.toJson(player.locker_list, "{}"),
                equip: SKDataUtil.toJson(player.getLockerEquipInfo(), "{}")
            };
            player.send('s2c_lockeritem', params);
        }
    }

    // 通知前端背包道具更新
    c2s_update_bagitem(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.update_bagitem(data);
        }
    }

    c2s_update_lockeritem(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (p) {
            p.update_lockeritem(data);
        }
    }

    c2s_createbang(data: any): number {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player == null || player.bangid > 0) {
            return 0;
        }
        let chargeCount = ChargeSum.shared.getPlayerChargeSum(player.roleid);
        // 充值判断
        // if (chargeCount < GameUtil.limitGreateBangChargeCount) {
        //     player.send('s2c_notice', {
        //         strRichText: `您已充值${chargeCount}元,创建帮会需要充值${GameUtil.limitGreateBangChargeCount}元以上`,
        //     });
        //     return 0;
        // }
        BangMgr.shared.createBang(player, data);
        let bang = BangMgr.shared.getBang(player.bangid);
        if (bang) {
            SKCxfUtil.getCxfRecordOperate({
                roleId: player.roleid,
                roleName: player.name,
                operateType: Operate.BANG,
                operateDepict: "创建帮派",
                operateResSerial: player.bangid,
                operateResName: bang.name,
                operateContent: SKDataUtil.toJson(bang.toObj(), "{}")
            })
        }
        return 1;
    }

    c2s_joinbang(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!player || player.bangid > 0) {
            return;
        }
        if (BangMgr.shared.joinBang(player.roleid, data.bangid)) {
            this.c2s_getbanginfo(data);
        } else {
            this.send('s2c_operation_result', {
                code: MsgCode.FAILED,
            });
        }
    }

    c2s_requestbang(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!player) {
            return;
        }
        if (player.bangid > 0) {
            player.send('s2c_notice', {
                strRichText: '申请失败'
            });
            return;
        }
        BangMgr.shared.requestBang(player, data.bangid);
    }

    c2s_operbang(data: any) {
        let master = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (master == null) {
            return;
        }
        let bang = BangMgr.shared.getBang(data.bangid);
        if (bang == null) {
            return;
        }
        bang.operRequest(master, data.roleid, data.operation);
    }

    c2s_leavebang(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player == null) {
            return;
        }
        let bang = BangMgr.shared.getBang(data.bangid);
        if (bang == null) {
            return;
        }

        if (player.roleid == data.roleid) {
            if (bang.masterid == player.roleid) {
                BangMgr.shared.disbandBang(data)
            } else {
                bang.leave(data.roleid, 0);
            }
            player.send('s2c_leavebang', {
                ecode: MsgCode.SUCCESS
            });
        } else {
            if (bang.masterid != player.roleid) {
                return;
            }
            bang.leave(data.roleid, 1);
            let tplayer = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
            if (tplayer) {
                tplayer.send('s2c_leavebang', {
                    ecode: MsgCode.SUCCESS
                });
            }
            this.c2s_getbanginfo({
                roleid: player.roleid,
                bangid: data.bangid
            });
        }
    }

    c2s_getbanglist() {
        this.send('s2c_getbanglist', {
            list: BangMgr.shared.getBangList()
        });
    }

    c2s_getbangrequest(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player == null) {
            return;
        }

        let bang = BangMgr.shared.getBang(player.bangid);
        if (bang) {
            if (bang.masterid != data.roleid) {
                return;
            } else {
                this.send('s2c_getbangrequest', {
                    requestlist: bang.getBangRequest()
                });
            }
        }
    }

    c2s_getbanginfo(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (p) {
            if (p.bangid != data.bangid) {
                this.c2s_getbanglist();
                return;
            }
            BangMgr.shared.playerGetBangInfo(p);
        }
    }

    c2s_searchbang(data: any) {
        if (data.data == null || data.data == 0 || data.data == '') {
            return;
        }
        this.send('s2c_getbanglist', {
            list: BangMgr.shared.searchBang(data)
        });
    }

    c2s_bang_bid(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (p) {
            let bang = BangMgr.shared.getBang(p.bangid);
            if (bang) {
                bang.addBidding(p, data.money);
            }
        }
    }

    //帮派任命
    c2s_set_bangpost(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.masterid);
        let member = PlayerMgr.shared.getPlayerByRoleId(data.memberid);
        if (!member) {
            player.send_notice("该成员未上线！");
            return;
        }
        if (player) {
            let bang = BangMgr.shared.getBang(player.bangid);
            if (bang) {
                if (bang.masterid != data.masterid) {
                    player.send_notice("只有帮主才有权操作哦！");
                    return;
                }
                if (data.postid == 2 || data.postid == 3 || data.postid == 4) {
                    for (const roleInfo of bang.rolelist) {
                        if (roleInfo.bangpost == data.postid) {
                            player.send_notice("该职位人数已达上限！");
                            return;
                        }
                    }
                } else if (data.postid == 5 || data.postid == 6) {
                    let count = 0;
                    for (const roleInfo of bang.rolelist) {
                        if (roleInfo.bangpost == data.postid) {
                            count++;
                        }
                    }
                    if (data.postid == 5 && count >= 5) {
                        player.send_notice("该职位人数已达上限！");
                        return;
                    }
                    if (data.postid == 6 && count >= 2) {
                        player.send_notice("该职位人数已达上限！");
                        return;
                    }
                }
                let post = bang.setBangPost(data.memberid, data.postid);
                if (post) {
                    if (player) {
                        SKCxfUtil.getCxfRecordOperate({
                            roleId: player.roleid,
                            roleName: player.name,
                            operateType: Operate.BANG,
                            operateDepict: "帮派任命",
                            operateResSerial: data.memberid,
                            operateResName: member.name,
                            operateContent: SKDataUtil.toJson(bang.rolelist, "{}")
                        })
                    }
                    player.send_notice("任命成功")
                    player.send('s2c_getbanginfo', bang.getBangInfo());
                } else {
                    player.send_notice("任命失败，该成员还未上线！")
                }
            }
        }
    }

    //帮派公告
    c2s_issue_affiche(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            let bang = BangMgr.shared.getBang(player.bangid);
            if (bang && data.type == 2 && player.bangpost <= 4 && player.bangpost > 0) { //护法以上有权发公告
                bang.issueAffiche(data);
            } else if (bang && data.type == 1 && player.bangpost == 1) { //帮主有权更改帮派宗旨
                bang.issueAffiche(data);
            } else {
                player.send_notice("你没有这个权限");
            }
        }
    }

    //帮派升级
    c2s_bang_up(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            let bang = BangMgr.shared.getBang(player.bangid);
            if (bang) {
                bang.bangUp(data.roleid);
            }
        }
    }

    // 召唤兽转生
    c2s_relive_pet(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            player.relivePet(data);
        }
    }

    c2s_wash_petproperty(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (p) {
            p.washProperty(data);
        }
    }

    c2s_save_petproperty(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (p) {
            p.savePetProperty(data);
        }
    }

    c2s_charge_reward(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            player.chargeReward(data);
        }
    }

    c2s_special_reward(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            player.spChargeReward(data);
        }
    }

    // 请求召唤兽合成
    c2s_hecheng_pet(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            player.hechengPet(data);
        }
    }

    c2s_create_pet(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (p) {
            p.createPet(data);
        }
    }

    c2s_get_petlist(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (p) {
            p.getPetlist(data);
        }
    }

    c2s_change_pet(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (p) {
            p.changePet(data.petid);
        }
    }

    c2s_update_pet(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.updatePetPoint(data);
        }
    }

    c2s_pet_info(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            for (let pet of player.petList) {
                if (pet.petid == data.petid) {
                    player.send('s2c_pet_info', {
                        info: pet.toObj()
                    });
                }
            }
        }
    }

    c2s_level_reward(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (p) {
            p.levelReward(data.level);
        }
    }

    // 请求删除召唤兽
    c2s_del_pet(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.delPet(data);
        }
    }

    c2s_pet_forgetskill(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (p) {
            p.petForgetSkill(data.petid, data.skillid)
        }
    }

    c2s_pet_lockskill(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (p) {
            p.petLockSkill(data.petid, data.skillid)
        }
    }

    c2s_pet_changeSskill(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!p) {
            return;
        }

        p.petShenShouSkill(data.petid, data.skillid);
    }

    c2s_creat_equip(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.createEquip(data);
        }
    }

    // 请求装备列表
    c2s_equip_list(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.sendEquipList();
        }
    }

    c2s_equip_info(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.sendEquipInfo(data.equipid);
        }
    }

    c2s_next_equip(data: any) {
        let equipArr = EquipMgr.shared.getEquipData(data);
        this.send('s2c_next_equip', {
            equip: SKDataUtil.toJson(equipArr, "{}")
        });
    }

    c2s_equip_update(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.updateEquip(data);
        }
    }

    c2s_equip_upgrade(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (p) {
            p.upgradeEquip(data);
        }
    }

    // 装备镶嵌
    c2s_equip_inlay(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.equipInlay(data);
        }
    }

    c2s_equip_refine(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.equipRefine(data);
        }
    }

    // 获取属性评分
    c2s_attribute_score(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            player.attributeScore(data);
        }
    }

    // 道具分解
    c2s_item_resolve(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            player.itemResolve(data);
        }
    }

    // 佩饰重铸
    c2s_baldric_recast(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.baldricRecast(data);
        }
    }

    // 佩饰分解
    c2s_baldric_resolve(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.baldricResolve(data);
        }
    }

    // 配饰鉴定
    c2s_acc_authenticate(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.accAuthenticate(data);
        }
    }

    // 装备重铸
    c2s_equip_recast(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.equipRecast(data);
        }
    }

    // 装备分解
    c2s_equip_resolve(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.equipResolve(data);
        }
    }

    c2s_xianqi_list(data: any) {
        let equipArr = EquipMgr.shared.getXianQiList(data);
        this.send('s2c_xianqi_list', {
            list: SKDataUtil.toJson(equipArr, "[]")
        });
    }

    c2s_shenbing_upgrade(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (p) {
            p.shenbignUpgrade(data);
        }
    }

    // 仙器升阶
    c2s_xianqi_upgrade(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.xianqiUpGrade(data);
        }
    }

    c2s_btl(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            if (player.battle_id == 0) {
                player.monsterBattle();
            }
        }
    }

    c2s_btl_auto(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            let battle: any = BattleMgr.shared.getBattle(player.battle_id);
            if (battle) {
                battle.playerAuto(player.onlyid);
            }
        }
    }

    // 请求战斗动作
    c2s_btl_act(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            let battle = BattleMgr.shared.getBattle(player.battle_id);
            if (battle) {
                battle.playerAction(data);
            }
        }
    }


    c2s_mall_buy(data: any) {
        //data.id;
    }

    // c2s_Get_WX(){
    //     let str1 = `select *  from qy_WX`;
    //     DB.query(str1, (ret, rows) => {
    //         let data = rows;
    //         this.send('s2c_Get_WX', {
    //             data: data,
    //         })
    //     });
    // }

    c2s_relive(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            player.playerRelive(data);
        }
    }

    // 请求飞升
    c2s_fly_up(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            player.playerFlyUp(data);
        }
    }

    c2s_changerace(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            player.playerChangeRace(data);
        }
    }

    // 修改角色名称
    c2s_changename(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            player.playerChangeName(data);
        }
    }

    // 修改宠物名称
    c2s_update_pet_name(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (p) {
            p.playerChangePetName(data);
        }
    }

    c2s_pk(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            let target = PlayerMgr.shared.getPlayerByRoleId(data.troleid);
            if (target) {
                player.playerBattle(target.onlyid, data.type);
            }
        }
    }

    //竞技场pk
    c2s_arenaPK(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player && player.teamid == 0) {
            JingJiChang.shared.battleStart(player.roleid, data.troleid);
        } else {
            player.send_notice("请先退出队伍");
        }
    }

    //
    c2s_report(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.troleid);
        if (player) {
            let senddata = SKDataUtil.toJson(JingJiChang.shared.getReportByRoleid(player.roleid), "{}");
            player.send('s2c_report_info', {
                report: senddata
            });
        }
    }

    c2s_hongbao_open(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            let activity = ActivityMgr.shared.getActivity(ActivityDefine.activityKindID.HongBao);
            if (activity) {
                activity.playerOpenHongbao(player.roleid);
            }
        }
    }

    c2s_getgift_info() {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!player) {
            return;
        }
        let senddata: any = {}
        senddata.hasgot = player.getgift;
        senddata.list = [];
        let gift = require('../gift/gift');
        for (let itemid in gift.libao) {
            const itemnum = gift.libao[itemid];
            senddata.list.push({
                itemid: itemid,
                itemnum: itemnum,
            });
        }
        this.send('s2c_getgift_info', senddata);
    }

    c2s_resetgift() {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!player) {
            return;
        }
        player.getgift = 1;
    }

    // 请求首冲礼包
    c2s_remunerate(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!player) {
            return;
        }
        let errorcode = player.reGetGift();
        this.send('s2c_aoi_pinfo', {
            list: [player.toObj()]
        });
        this.send('s2c_remunerate', {
            errorcode: errorcode,
        })
    }

    c2s_shuilu_sign(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            if (player.isTeamLeader() == false) {
                return;
            }
            let activity = ActivityMgr.shared.getActivity(ActivityDefine.activityKindID.ShuiLuDaHui);
            if (activity && activity.activity_state == ActivityDefine.activityState.Opening) {
                let errorcode = activity.playerSign(player);
                // 成功通知全体成员，失败则通知队长一人
                if (MsgCode.SUCCESS == errorcode) {
                    TeamMgr.shared.broadcast(player.getTeamId(), 's2c_shuilu_sign', {
                        errorcode: errorcode,
                        shuilustate: activity.sldh_state,
                    });
                    player.map_transfer(1213);
                } else {
                    this.send('s2c_shuilu_sign', {
                        errorcode: errorcode,
                        shuilustate: activity.sldh_state,
                    });
                }
            } else {
                this.send('s2c_shuilu_sign', {
                    errorcode: MsgCode.SLDH_NOT_OPEN
                });
            }
        }
    }

    c2s_shuilu_unsign(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            if (player.isTeamLeader() == false) {
                return;
            }
            let activity = ActivityMgr.shared.getActivity(ActivityDefine.activityKindID.ShuiLuDaHui);
            if (activity && activity.activity_state == ActivityDefine.activityState.Opening) {
                let errorcode = activity.playerUnsign(player);
                if (MsgCode.SUCCESS == errorcode) {
                    TeamMgr.shared.broadcast(player.getTeamId(), 's2c_shuilu_unsign', {
                        errorcode: errorcode
                    });
                } else {
                    this.send('s2c_shuilu_unsign', {
                        errorcode: errorcode
                    });
                }
            } else {
                this.send('s2c_shuilu_unsign', {
                    errorcode: MsgCode.SLDH_NOT_OPEN
                });
            }
        }
    }

    c2s_shuilu_info() {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            let activity = ActivityMgr.shared.getActivity(ActivityDefine.activityKindID.ShuiLuDaHui);
            if (activity && activity.activity_state == ActivityDefine.activityState.Opening) {
                let senddata = activity.getShuiLuInfo(player);
                this.send('s2c_shuilu_info', senddata);
            } else {
                this.send('s2c_shuilu_sign', {
                    errorcode: MsgCode.SLDH_NOT_OPEN
                });
            }
        }
    }


    c2s_world_reward(data: any) {
        WorldRewardMgr.shared.sendReward(data.roleid, data.yuNum, data.num);
    }

    c2s_world_reward_list() {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!player) {
            return;
        }
        WorldRewardMgr.shared.getRewardList(player);
    }

    c2s_world_reward_open(data: any) {
        WorldRewardMgr.shared.toReceive(data.tagID, data.roleid);
    }

    c2s_title_change(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            player.changeTitle(data);
        }
    }

    c2s_title_info(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            player.getTitles();
        }
    }

    c2s_linghou_fight(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            let activity = ActivityMgr.shared.getActivity(ActivityDefine.activityKindID.TianJiangLingHou);
            if (activity && activity.activity_state == ActivityDefine.activityState.Opening) {
                let ecode = activity.playerFightMonkey(player, data.mid);
                if (ecode != MsgCode.SUCCESS) {
                    this.send('s2c_linghou_fight', {
                        ecode: ecode
                    });
                }
            } else {
                this.send('s2c_linghou_fight', {
                    ecode: MsgCode.LINGHOU_FIGHT_TOO_MACH
                });
            }
        }
    }

    c2s_palace_fight(data: any) {
        let subJade = 2000;
        let subMoney = 1500000;
        if (data.sponsorid == data.recipientid) {
            this.send('s2c_notice', {
                strRichText: '不能跟自己决斗！'
            });
            return;
        }
        if (PalaceFight.shared.getPKInfo(data.sponsorid) || PalaceFight.shared.getPKInfo(data.recipientid)) {
            this.send('s2c_notice', {
                strRichText: '你或者此玩家正在被其他人邀请皇城pk中！'
            });
            return;
        }
        let sponsor_role = PlayerMgr.shared.getPlayerByRoleId(data.sponsorid);
        let recipient_role = PlayerMgr.shared.getPlayerByRoleId(data.recipientid);
        if (!recipient_role || !sponsor_role) {
            this.send('s2c_notice', {
                strRichText: '未找到玩家！'
            });
            return;
        }
        if (!recipient_role.getIsOnline() || !sponsor_role.getIsOnline()) {
            this.send('s2c_notice', {
                strRichText: '玩家未在线！'
            });
            return;
        }
        if (recipient_role.level < 160 || sponsor_role.level < 160) {
            this.send('s2c_notice', {
                strRichText: '玩家等级未到160级！'
            });
            return;
        }
        if (data.type == 0) {
            if (sponsor_role.money < subMoney) {
                this.send('s2c_notice', {
                    strRichText: '玩家银两不够！'
                });
                return;
            }
            sponsor_role.addMoney(0, -subMoney, `玩家${data.sponsorid}对玩家${data.recipientid}发起皇城决斗！`);
        }
        if (data.type == 1) {
            if (sponsor_role.jade < subJade) {
                this.send('s2c_notice', {
                    strRichText: '玩家仙玉不够！'
                });
                return;
            }
            sponsor_role.addMoney(1, -subJade, `玩家${data.sponsorid}对玩家${data.recipientid}发起皇城决斗！`);
        }
        let sponsor = {
            roleid: sponsor_role.roleid,
            name: sponsor_role.name,
            level: sponsor_role.level,
            race: sponsor_role.race,
            resid: sponsor_role.resid,
            state: 1,
        };
        let recipient = {
            roleid: recipient_role.roleid,
            name: recipient_role.name,
            level: recipient_role.level,
            race: recipient_role.race,
            resid: recipient_role.resid,
            state: 0,
        };
        let senddata = {
            sponsor: sponsor,
            recipient: recipient,
            type: data.type,
            tm: 120 * 1000,
            msg: data.msg,
            win: 0,
        };
        PalaceFight.shared.addToList(senddata);
        if (data.type == 0) {
            this.send('s2c_palace_fight', senddata);
            recipient_role.send('s2c_palace_fight', senddata);
        } else if (data.type == 1) {
            PlayerMgr.shared.broadcast('s2c_palace_fight', senddata);
            let str = `玩家[${senddata.sponsor.name}]向玩家[${senddata.recipient.name}]发起了皇城决斗邀请！并写下战书`;
            if (data.msg.length == 0) {
                str = `玩家[${senddata.sponsor.name}]向玩家[${senddata.recipient.name}]发起了皇城决斗邀请！`;
            }
            PlayerMgr.shared.broadcast('s2c_game_chat', {
                roleid: sponsor_role.roleid,
                onlyid: sponsor_role.onlyid,
                scale: Channel.WORLD,
                msg: str,
                name: sponsor_role.name,
                resid: sponsor_role.resid,
            });
        }
        this.send('s2c_game_chat', {
            scale: Channel.SYSTEM,
            msg: `你向玩家[${senddata.recipient.name}]发起了皇城决斗邀请！`,
        });
        recipient_role.send('s2c_game_chat', {
            scale: Channel.SYSTEM,
            msg: `玩家[${senddata.sponsor.name}]向你发起了皇城决斗邀请！`,
        });
    }

    c2s_palace_agree(data: any) {
        let role = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (!role) {
            return;
        }
        let info = PalaceFight.shared.getPKInfo(data.roleid);
        if (!info) {
            this.send('s2c_notice', {
                strRichText: '决斗已被取消！'
            });
            return;
        }
        for (let item of [info.sponsor, info.recipient]) {
            if (item.roleid == data.roleid) {
                item.state = (data.battle == 1) ? 1 : 2;
            }
        }
        let sponsor_role = PlayerMgr.shared.getPlayerByRoleId(info.sponsor.roleid);
        let recipient_role = PlayerMgr.shared.getPlayerByRoleId(info.recipient.roleid);
        if (!sponsor_role || !recipient_role) {
            return;
        }


        if (info.sponsor.state == 1 && info.recipient.state == 1) { // 两人都同意决斗
            if (!sponsor_role.canPalaceFight()) {
                info.sponsor.state = 2;
                PalaceFight.shared.delPKInfo(data.roleid, 'sponsor');
            } else if (!recipient_role.canPalaceFight()) {
                info.recipient.state = 2;
                PalaceFight.shared.delPKInfo(data.roleid, 'recipient');
            } else {
                PalaceFight.shared.setCanPK(info);
            }
        }

        sponsor_role.send('s2c_palace_fight', info);
        recipient_role.send('s2c_palace_fight', info);

        if (info.sponsor.state == 2) { // 发起人取消决斗
            PalaceFight.shared.delPKInfo(data.roleid, 'sponsor');
        }
        if (info.recipient.state == 2) { // 接受人取消了决斗
            PalaceFight.shared.delPKInfo(data.roleid, 'recipient');
        }
    }

    c2s_palace_rolelist(data: any) {
        PalaceFight.shared.sendPalaceRoleList(data.roleid);
    }

    c2s_relation_new(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (!p) {
            return;
        }
        RelationMgr.shared.applyRelation(p, data);
    }

    c2s_relation_agree(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (!p) {
            return;
        }
        RelationMgr.shared.confirmRelation(p, data);
    }

    c2s_relation_List(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (!p) {
            return;
        }
        RelationMgr.shared.getRelationListByRoleId(p, data);
    }

    c2s_relation_leave(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (!p) {
            return;
        }
        RelationMgr.shared.leaveRelation(p, data);
    }

    c2s_relation_add(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (!p) {
            return;
        }
        RelationMgr.shared.addRelationMember(p, data);
    }

    c2s_relation_reject(data: any) {
        let p = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (!p) {
            return;
        }
        RelationMgr.shared.rejectRelation(p, data);
    }

    // 请求染色
    c2s_change_role_color(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            player.setRoleColor(data.index1, data.index2);
        }
    }

    c2s_scheme_create(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (!player) {
            return;
        }
        player.schemeMgr.addScheme(data.name);
    }

    c2s_scheme_List(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (!player) {
            return;
        }
        player.schemeMgr.getSchemeNameList();
    }

    c2s_scheme_info(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (!player) {
            return;
        }
        player.schemeMgr.getSchemeInfo(data.schemeId);
    }

    c2s_scheme_updateEquip(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (!player) {
            return;
        }
        player.schemeMgr.updateSchemeEquip(data);
    }

    c2s_scheme_addCustomPoint(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (!player) {
            return;
        }
        player.schemeMgr.addCustomPoint(data);
    }

    c2s_scheme_addXiulianPoint(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (!player) {
            return;
        }
        player.schemeMgr.addXiulianPoint(data);
    }

    c2s_scheme_resetXiulianPoint(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (!player) {
            return;
        }
        player.schemeMgr.resetXiulianPoint(data);
    }

    c2s_scheme_changePartner(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (!player) {
            return;
        }
        player.schemeMgr.changePartner(data);
    }

    c2s_scheme_activate(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (!player) {
            return;
        }
        player.schemeMgr.activateScheme(data);
    }

    c2s_scheme_changeName(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (!player) {
            return;
        }
        player.schemeMgr.changeScheneName(data);
    }

    c2s_scheme_use(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (!player) {
            return;
        }
        player.schemeMgr.useSchene(data);
    }

    // 世界铃铛
    c2s_bell_msg(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!player) {
            return;
        }
        let chargeTotal = ChargeSum.shared.getPlayerChargeSum(player.roleid);
        if (chargeTotal < GameUtil.bellMsg) {
            let msg = `世界铃铛必须累计充值${GameUtil.bellMsg}元，才可以使用哦！`;
            player.send('s2c_notice', {
                strRichText: msg
            });
            return;
        }
        player.costBell(data.msg);
    }

    c2s_safepass_msg(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!player) {
            return;
        }
        player.setSafePassword(data.pass, data.lock);
    }

    c2s_petfly_msg(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!player) {
            return;
        }
        let pet = player.getPetByID(data.petid);
        if (!pet) {
            return;
        }
        pet.flyingUp(data.type);
    }

    // 骑乘
    c2s_ride(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player != null) {
            let horseIndex = data.horseIndex;
            player.ride(horseIndex);
            return;
        }
    }

    // 下马
    c2s_get_down(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player != null) {
            player.get_down();
            return;
        }
    }

    // 坐骑升级
    c2s_horse_upgrade(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            player.upgradeHorse(data);
            return;
        }
    }

    c2s_pet_control(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            player.petControl(data);
        }
    }

    c2s_horse_skill(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            player.getHorseSkill();
        }
    }

    c2s_upgrade_skill(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            player.upgradeHorseSkill(data);
        }
    }

    // 坐骑洗炼
    c2s_horse_refining(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            if (player.relive < 1) {
                player.send_notice("未转生不能洗练坐骑！");
                return;
            }
            player.horseRefining(data);
        }
    }

    // 领取每日充值奖励
    c2s_day_reward(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            player.dayReward(data);
        }
    }

    // 领取VIP每日奖励
    c2s_vip_reward(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            player.vipReward(data);
        }
    }

    // 请求挖宝列表
    c2s_dug_list(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            player.dugList(data);
        }
    }

    // 开挖
    c2s_dug(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            player.dug(data);
        }
    }

    // 物品信息
    c2c_goods_info(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            player.goodsInfo(data);
        }
    }

    // 请求开启背包格子
    c2c_open_backpack_grid(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            player.openBackpackGrid();
        }
    }

    // 当前月签到数据
    c2c_sign_in(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            let value = SignInMgr.shared.getSignInData(player);
            // 角色ID：roleId 签到数据：signInData 当前日(1-31)：day
            this.send('s2c_sign_in', {
                roleId: data.roleId,
                signInData: SKDataUtil.toJson(value, "{}"),
                day: GTimer.getCurDay()
            });
        }
    }

    // 玩家签到
    c2c_check_in(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            SignInMgr.shared.signIn(data);
        }
    }

    // 玩家答题
    c2c_send_answer(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            RespondentsMgr.shared.getAnswer(data);
        }
    }

    // 开启宠物技能格子
    c2c_pet_skill_grid(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            player.openPetSkillGrid(data);
        }
    }

    //兑换码
    c2s_convert(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.checkExchange(data.code);
        }
    }

    //绑定信息
    c2s_bindinfo(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        let list = PaiHangMgr.shared.bind_player_list;
        let playerinfo = {};
        let infolist = [];
        if (player) {
            for (let key in list) {
                let bplayer = list[key];
                if (data.roleId == bplayer.roleid) {//当前绑定的哪个玩家
                    playerinfo = {
                        roleid: bplayer.bind_roleid,
                        name: bplayer.bind_name,
                        resid: bplayer.bind_resid,
                        relive: bplayer.bind_relive,
                        level: bplayer.bind_level
                    };
                    break;
                }
            }
            for (let key in list) {
                let bplayer = list[key];
                if (data.roleId == bplayer.bind_roleid) {//被哪些玩家绑定了
                    infolist.push({
                        roleid: bplayer.roleid,
                        name: bplayer.name,
                        resid: bplayer.resid,
                        relive: bplayer.relive,
                        level: bplayer.level
                    })
                }
            }
            player.send("s2c_bindinfo", {
                playerinfo: SKDataUtil.toJson(playerinfo, "{}"),
                bplayerinfo: SKDataUtil.toJson(infolist, "{}")
            });
        }
    }

    //新用户绑定
    c2s_binding(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        let bplayer = PlayerMgr.shared.getPlayerByRoleId(data.broleId);
        if (data.br == this.roleId) {
            this.send('s2c_notice', {
                strRichText: `不可以绑定自己！`
            })
            return;
        }
        if (player && bplayer) {
            player.roleBinding(bplayer);
        } else {
            this.send('s2c_notice', {
                strRichText: `玩家不存在，绑定失败！`
            })
        }
    }

    //重置今日充值存档
    c2s_clear_day(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.clearDayMap();
            //cxf重置今日充值存档
            SKCxfUtil.getCxfRecordOperate({
                roleId: player.roleid,
                roleName: player.name,
                operateType: Operate.ITEM,
                operateDepict: "重置今日充值存档",
                operateResSerial: "",
                operateResName: "",
                operateContent: ""
            })
        }
    }

    //变身卡详情
    c2s_become_info(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            let info = ChangeCard.shared.getCardInfoByCardId(data.cardid);
            this.send('s2c_become_info', {
                info: SKDataUtil.toJson(info, "{}")
            });
        }
    }

    //分解变身卡
    c2s_card_resolve(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            ChangeCard.shared.cardResolve(player, data);
        }
    }

    //批量分解配饰
    c2s_batch_resolve(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.send_notice("正在维护该功能")
            // for (let equip of player.listEquips) {
            //     if (equip.EquipType == 5){
            //         let delequip = null;
            //         for (let index = 0; index < player.listEquips.length; index++) {
            //             if (player.listEquips[index].EquipID == equip.EquipID) {
            //                 delequip = player.listEquips[index];
            //                 player.listEquips.splice(index, 1);
            //                 break;
            //             }
            //         }
            //         let score = 10;
            //         if (equip.BaseAttr.length != 0 ){
            //             if (equip.Grade == 2) {
            //                 score = 20;
            //             } else if (equip.Grade == 3) {
            //                 score = 50;
            //             }
            //         }
            //         player.shuilu.gongji += score;
            //
            //         player.sendEquipList();
            //         player.send('s2c_you_money', {
            //             nKind: GameUtil.goldKind.SLDH_Score,
            //             nNum: player.shuilu.gongji,
            //             nChange: score
            //         });
            //         let info = `消耗[color=${ItemUtil.getBaldricColor(equip.Grade)}][${equip.name}][/color]X1得到功绩${score}`;
            //         player.send('s2c_notice', {
            //             strRichText: info
            //         });
            //         if (delequip != null) {
            //             player.unInLay(delequip);
            //             delequip.pos = EEquipPos.UNKNOW;
            //             let equipfulldata = delequip.getFullData();
            //             SKLogger.debug(`玩家[${player.roleid}:${player.name}]删除装备[${delequip.EquipID}:${equipfulldata.EName}]:配饰分解]`);
            //             delequip.state = 0;
            //             delequip.save();
            //             delete player.equipObjs[delequip.EquipID];
            //             EquipMgr.shared.delEquip(delequip.EquipID);
            //             player.schemeMgr.deleteCurEquips(delequip.EquipID);
            //         }
            //     }
            // }
            // player.send('s2c_bagitem', {
            //     info: SKDataUtil.toJson(player.bag_list, "{}")
            // });
        }
    }

    //五行修炼
    c2s_five_phases(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            let vecData = FivePhases.shared.getFivePhasesByRoleid(data.roleid, data.type);
            if (vecData != undefined && vecData != null) {
                this.send('s2c_five_phases', {
                    vecRow: SKDataUtil.toJson(vecData, "{}"),
                    upexp: vecData.upexp,
                    count: vecData.count
                });
            }
        }
    }

    //五行升级
    c2s_fplevel(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            FivePhases.shared.fplevelup(data);
        }
    }

    //变身卡详情页
    c2s_detail_page(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            let card = ChangeCard.shared.detailPage(player.roleid);
            if (card) {
                this.send('s2c_detail_page', {
                    card: SKDataUtil.toJson(card, "{}"),
                });
            } else {
                this.send('s2c_notice', {
                    strRichText: '没使用过变身卡或变身卡已到期'
                });
            }
        }
    }

    // 逐鹿大会报名
    c2s_join_say(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            if (player.isTeamLeader() == false) {
                return;
            }
            // 判断逐鹿大会是否开启
            if (SatAssembly.shared.activity_state == ActivityDefine.activityState.ReadyOpen) {
                let code = SatAssembly.shared.playerSign(player);
                // 成功通知全体成员，失败则通知队长一人
                if (MsgCode.SUCCESS == code) {
                    TeamMgr.shared.broadcast(player.getTeamId(), 's2c_join_say_sign', {
                        code: code,
                        sayState: SatAssembly.shared.activity_state,
                    });
                } else {
                    this.send('s2c_join_say_sign', {
                        code: code,
                        sayState: SatAssembly.shared.activity_state,
                    });
                }
            } else {
                this.send('s2c_join_say_sign', {
                    code: MsgCode.SAT_NOT_SIGN_TIME
                });
            }
        }
    }

    // 返回当前逐鹿大会队员信息及分数信息
    c2s_say_team_info(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            if (SatAssembly.shared.activity_state != ActivityDefine.activityState.Close) {
                SatAssembly.shared.say_team_info(player, data.teamId);
            } else {
                this.send('s2c_join_say_sign', {
                    code: MsgCode.SAT_NOT_OPEN
                });
            }
        }
    }

    // 请求逐鹿大会积分榜
    c2s_say_integral_info(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            if (SatAssembly.shared.activity_state != ActivityDefine.activityState.Close) {
                SatAssembly.shared.say_integral_info(player, data.type);
            } else {
                this.send('s2c_join_say_sign', {
                    code: MsgCode.SAT_NOT_OPEN
                });
            }

        }
    }

    // 请求离开水路大会
    c2s_leave_sldh(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            let activity = ActivityMgr.shared.getActivity(ActivityDefine.activityKindID.ShuiLuDaHui);
            if (activity && activity.activity_state == ActivityDefine.activityState.Opening) {
                let errorcode = activity.playerUnsign(player);
                if (MsgCode.SUCCESS == errorcode) {
                    TeamMgr.shared.broadcast(player.getTeamId(), 's2c_shuilu_unsign', {
                        errorcode: errorcode
                    });
                    player.map_transfer(1011);
                } else {
                    player.map_transfer(1011);
                }
            } else {
                // 获得未开启直接离开
                player.map_transfer(1011);
                player.send('s2c_leave_sat', {
                    code: MsgCode.SUCCESS
                });
            }

        }
    }

    // 请求离开逐鹿大会
    c2s_leave_sat(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            if (SatAssembly.shared.activity_state != ActivityDefine.activityState.Close) {
                SatAssembly.shared.leaveSat(player, data.teamId);
            } else {
                // 获得未开启直接离开
                player.map_transfer(1011);
                player.send('s2c_leave_sat', {
                    code: MsgCode.SUCCESS
                });
            }

        }
    }

    // 逐鹿巅峰对决主动挑战其他队伍
    c2s_sat_challenge(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            if (SatAssembly.shared.activity_state != ActivityDefine.activityState.Close) {
                SatAssembly.shared.challenge(player, data.rivalTeamId);
            }
        }
    }

    // 特效
    c2s_has_seffect(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            let list = SpecialEffect.shared.getSeffectbyId(data.roleid);
            if (list) {
                player.send('s2c_has_seffect', {
                    seffectlist: SKDataUtil.toJson(list, '{}')
                });
            }
        }
    }

    // 使用特效
    c2s_use_seffect(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            let list = SpecialEffect.shared.useSeffect(data);
            player.send('s2c_has_seffect', {
                seffectlist: SKDataUtil.toJson(list, '{}')
            });
        }
    }

    // 支援列表
    c2s_support_list(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            let list = PetSupport.shared.getPetlistById(data.roleid);
            player.send('s2c_support_list', {
                supportlist: SKDataUtil.toJson(list, '{}')
            });
        }
    }

    // 调整支援顺序
    c2s_support_order(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            let list = PetSupport.shared.supportOrder(data);
            player.send('s2c_support_list', {
                supportlist: SKDataUtil.toJson(list, '{}')
            });
        }
    }

    // 暂离队伍
    c2s_pause_team(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.pause = 1;
            TeamMgr.shared.sendInfoToMember(player.teamid);
        }
    }

    // 召回
    c2s_recall_team(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player && player.ischeck == 1) {
            player.pause = 0;
            TeamMgr.shared.sendInfoToMember(player.teamid);
            let pTeamInfo = TeamMgr.shared.teamList[player.teamid];
            TeamMgr.shared.teamMove(pTeamInfo);
        } else {
            player.send('s2c_recall_role', {
                roleid: player.roleid,
            });
        }
    }

    c2s_recall_confirm(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.pause = 0;
            TeamMgr.shared.sendInfoToMember(player.teamid);
            let pTeamInfo = TeamMgr.shared.teamList[player.teamid];
            TeamMgr.shared.teamMove(pTeamInfo);
        }
    }

    // 自动归队
    c2s_ischeck_on(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.ischeck = 1;
            TeamMgr.shared.sendInfoToMember(player.teamid);
        }
    }

    c2s_ischeck_off(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.ischeck = 0;
            TeamMgr.shared.sendInfoToMember(player.teamid);
        }
    }

    // 请求天牢犯人数据
    c2s_days_prisoner(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            this.send('s2c_days_prisoner', {
                prisoner: SKDataUtil.toJson(PaiHangMgr.shared.getDaysPrisoner(), "{}")
            });
        }
    }

    // 请求保释天牢犯人
    c2s_days_bail(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        let bail_player = PlayerMgr.shared.getPlayerByRoleId(data.bailRoleid);
        if (player) {
            if (bail_player) {
                if (bail_player.shane > 0) {
                    if (player.jade > 100000) {
                        player.addMoney(GameUtil.goldKind.Jade, -100000, "保释成功");
                        bail_player.shane = 0;
                        bail_player.send_notice(`您已经被玩家${player.name}进行保释！`)
                        // 更新监牢犯人数据
                        PaiHangMgr.shared.updateDaysPrisonerData(bail_player.roleid, bail_player.name, bail_player.race, bail_player.level, bail_player.relive, bail_player.shane);
                        // 更新监牢犯人数据给前端
                        player.send('s2c_days_prisoner', {
                            prisoner: SKDataUtil.toJson(PaiHangMgr.shared.getDaysPrisoner(), "{}")
                        });
                        bail_player.ShanEChange();
                        bail_player.send('s2c_aoi_pinfo', {
                            list: [bail_player.toObj()]
                        });
                    } else {
                        player.send_notice("您的保释金不足！");
                    }
                } else {
                    player.send_notice("您的保释玩家不在牢房！");
                }
            } else {
                player.send_notice("您的保释玩家信息查询失败！");
            }


        }
    }

    //设置离线时间
    c2s_set_offlinetime(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            player.offlinetime = data.offtime;
            player.send_notice('离线时间修改成功')
        }
    }

    //天策符列表
    c2s_own_ofuda(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            // player.send_notice("该功能正在维护！");
            // return;
            Ofuda.shared.getOfudaListByRoid(data.roleid)
        }
    }

    //天演策列表
    c2s_ofuda_list(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            // player.send_notice("该功能正在维护！");
            // return;
            let list = Ofuda.shared.getOfudaList();
            let level = 0;
            let bang = BangMgr.shared.getBang(player.bangid);
            if (bang) {
                let list = bang.rolelist;
                for (let key in list) {
                    if (player.roleid == list[key].roleid) {
                        level = list[key].ofudalevel;
                        break;
                    }
                }
            } else {
                player.send_notice("加入帮派才能使用哦")
                return;
            }
            player.send("s2c_ofuda_list", {
                list: SKDataUtil.toJson(list, "{}"),
                level: level
            })
            this.c2s_own_ofuda({ roleid: player.roleid })
        }
    }

    c2s_open_levelup(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            let bang = BangMgr.shared.getBang(player.bangid);
            if (bang) {
                let list = bang.rolelist;
                for (let key in list) {
                    let role = list[key];
                    if (role.roleid == data.roleid) {
                        let jade = 100000 + role.ofudalevel * 5888 + 1237
                        let bangscore = 1000 + role.ofudalevel * 1888 + 1237
                        player.send("s2c_open_levelup", {
                            jade: jade,
                            score: bangscore,
                            level: role.ofudalevel,
                        })
                        break;
                    }
                }
            }
        }
    }

    //天演策升级
    c2s_ofuda_levelup(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            // player.send_notice("该功能正在维护！");
            // return;
            let isUp = Ofuda.shared.levelUp(data)
            if (isUp) {
                this.c2s_open_levelup({ roleid: player.roleid })
            }
        }
    }

    //合成天策符
    c2s_compound_ofuda(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            // player.send_notice("该功能正在维护！");
            // return;
            if (data.count > 10) {
                player.send_notice("最多一次合成10个！");
                return;
            }
            Ofuda.shared.compoundOfuda(data)
        }
    }

    //鉴定天策符
    c2s_authenticate_ofuda(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            // player.send_notice("该功能正在维护！");
            // return;
            if (data.count > 10) {
                player.send_notice("最多一次鉴定10个！");
                return;
            }
            Ofuda.shared.ahcOfuda(data);
        }
    }

    //分解天策符
    c2s_resolve_ofuda(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            // player.send_notice("该功能正在维护！");
            // return;
            Ofuda.shared.resolveOfuda(data);
        }
    }
    //批量分解天策符
    c2s_batchResolve_ofuda(data: any) {
        let ms1 = new Date().getMilliseconds();
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        let ofudalist = Ofuda.shared.pofuda_map.get(data.roleid);
        if (ofudalist == null || ofudalist == undefined) {
            return;
        }
        if (player) {
            // player.send_notice("该功能正在维护！");
            // return;
            player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
            let list = SKDataUtil.jsonBy(data.ofudalist);
            let num = 0;
            if (list && list.length > 10) {
                player.send_notice("最多一次分解10个！")
                return;
            }
            for (let id of list) {
                for (let key in ofudalist) {
                    let ofuda = ofudalist[key];
                    if (ofuda == null || ofuda == undefined) {
                        continue;
                    }
                    if (id == ofuda.ofudaid && ofuda.roleid == data.roleid) {
                        if (ofuda.grade == 1) {
                            num += 1;
                        }
                        if (ofuda.grade == 2) {
                            num += 5;
                        }
                        if (ofuda.grade == 3) {
                            num += 10;
                        }
                        delete ofudalist[key];
                        break;
                    }
                }
            }
            player.addBagItem(100320, num, true);
            let ms2 = new Date().getMilliseconds();
            let time = ms2 - ms1;
            SKLogger.info(`批量分解 - 处理时间${time}ms`)
            this.c2s_own_ofuda({ roleid: player.roleid });
        }
    }

    //使用天策符
    c2s_use_ofuda(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            // player.send_notice("该功能正在维护！");
            // return;
            Ofuda.shared.useOfuda(data);
            this.c2s_ofuda_list({ roleid: player.roleid });
            this.c2s_own_ofuda({ roleid: player.roleid });
        }
    }

    //邀请入队
    c2s_team_invite(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        let toplayer = PlayerMgr.shared.getPlayerByRoleId(data.toroleid);
        if (player && toplayer) {
            let team = TeamMgr.shared.getTeamInfo(player.teamid);
            if (team == undefined || team == null) {
                player.send_notice("你还没有队伍，去创建队伍吧！");
                return;
            }
            if (!player.isleader) {
                player.send_notice("你不是队长！")
                return;
            }
            if (team.playerlist >= 5) {
                player.send_notice("队伍已满！")
                return;
            }
            if (toplayer.teamid > 0) {
                player.send_notice("他已经有队伍了，拉拉别人吧!");
                return;
            }
            if (player.mapid == 3001 && player.bangid != toplayer.bangid) {
                player.send_notice("帮战时间不能邀请其他帮派的成员入队！");
                return;
            }
            if (player.mapid == 3001 && toplayer.mapid != player.mapid) {
                player.send_notice("该玩家还未参加本次帮战，快去通知他参加吧！");
                return;
            }
            if (player.mapid == 1213 && toplayer.mapid != player.mapid) {
                player.send_notice("该玩家还未参加本次活动，快去通知他参加吧！");
                return;
            }
            if (player.mapid == 4004 && toplayer.mapid != player.mapid) {
                player.send_notice("该玩家还未参加本次活动，快去通知他参加吧！");
                return;
            }
            toplayer.send('s2c_team_invite', {
                leaderid: team.leader.roleid,
                toroleid: toplayer.roleid,
                leadername: team.leader.name
            })
        }
    }
    c2s_oper_invite(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        let leader = PlayerMgr.shared.getPlayerByRoleId(data.leaderid);
        if (player) {
            if (data.operation == 0) {
                leader.send_notice("玩家拒绝了你的邀请！")
            }
            if (data.operation == 1) {
                TeamMgr.shared.joinTeam(player, leader.teamid);
            }
        }
    }

    c2s_paihang_playerinfo(data: any) {
        let role = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        let player = PlayerMgr.shared.getPlayerByRoleId(data.playerid);
        if (role) {
            if (player) {
                let info = player.getPlayerInfoById();
                role.send('s2c_paihang_playerinfo', {
                    info: SKDataUtil.toJson(info, '{}')
                })
            } else {
                role.send_notice("该玩家不在线，无法查看");
            }
        }
    }

    // 请求进入帮战
    c2s_gang_wars(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            let code = FactionWar.shared.playerSign(player);
            // 成功通知全体成员，失败则通知队长一人
            if (MsgCode.SUCCESS == code) {
                if (player.teamid > 0) {
                    TeamMgr.shared.broadcast(player.getTeamId(), 's2c_gang_wars', {
                        code: code,
                        state: FactionWar.shared.activity_state
                    });
                } else {
                    player.send('s2c_gang_wars', {
                        code: code,
                        state: FactionWar.shared.activity_state
                    });
                }

            }
        }
    }

    // 帮战信息统计
    c2s_detail_statistics(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            FactionWar.shared.detail_statistics(player)
        }
    }

    // 上阵迎敌
    c2s_to_meet_them(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            if (FactionWar.shared.activity_state == ActivityDefine.activityState.Opening) {
                FactionWar.shared.toMeetThem(player);
            } else {
                player.send_notice("帮战未开始");
            }
        }
    }

    // 帮战点击敌方战斗
    c2s_faction_combat(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        let enemyRole = PlayerMgr.shared.getPlayerByRoleId(data.enemyRoleId);
        if (player && enemyRole) {
            if (FactionWar.shared.activity_state == ActivityDefine.activityState.Opening) {
                FactionWar.shared.factionCombat(player, enemyRole);
            } else {
                player.send_notice("帮战未开始");
            }
        }
    }

    // 前往比武场
    c2s_go_contest(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            if (FactionWar.shared.activity_state == ActivityDefine.activityState.Opening) {
                FactionWar.shared.goContest(player);
            } else {
                player.send_notice("帮战未开始");
            }
        }
    }

    // 返回长安
    c2s_to_map_chang_an(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            if (data.type == 1) {
                FactionWar.shared.leave(player);
            }
            player.map_transfer(1011);
        }
    }

    // 返回基地
    c2s_go_home(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            FactionWar.shared.goHome(player, data.type);
        }
    }

    // 帮战-比武
    c2s_contest(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            if (FactionWar.shared.activity_state == ActivityDefine.activityState.Opening) {
                FactionWar.shared.contest(player);
            } else {
                player.send_notice("帮战未开始");
            }
        }
    }

    // 帮战-请求塔的信息
    c2s_gang_tower(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            if (FactionWar.shared.activity_state == ActivityDefine.activityState.Opening) {
                FactionWar.shared.tower_info(player, data.towerId);
            } else {
                player.send_notice("帮战未开始，城防设备不可使用");
            }
        }
    }

    // 帮战-请求城防建筑
    c2s_ask_fortifications(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleId);
        if (player) {
            if (FactionWar.shared.activity_state == ActivityDefine.activityState.Opening) {
                if (data.type == 1) {
                    // 请求大炮
                    SKLogger.info(`${player.name}-帮派编号${player.bangid}操作大炮${data.is == 0 ? "蓄力" : "打断"}`)
                    FactionWar.shared.cannon_action(player, data.is);
                } else {
                    // 请求烈火塔 玄冰塔
                    SKLogger.info(`${player.name}-帮派编号${player.bangid}操作${data.type == 2 ? "烈火塔" : "玄冰塔"}${data.is == 0 ? "蓄力" : "打断"}`)
                    FactionWar.shared.tower_action(player, data.is, data.serial);
                }
            } else {
                player.send_notice("帮战未开始，城防设备不可使用");
            }
        }
    }
    // 请求碎片商城
    c2s_debris_mall(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            DebrisMall.shared.getDebrisMallData(player);
        }
    }

    // 请求碎片商城兑换
    c2s_debris_mall_convert(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            DebrisMall.shared.getDebrisMallConvert(player, data.serial);
        }
    }
    // 领取双倍点数
    c2s_get_doublecnt(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            if (player.unget_doublecnt <= 0) {
                player.send_notice("没有可领取的点数");
                return;
            }
            if (player.unget_doublecnt < 60) {
                player.doublecnt += player.unget_doublecnt;
                player.send_notice(`领取${player.unget_doublecnt}点双倍点数`);
                player.unget_doublecnt = 0;
                player.getTaskMgr().SendDailyActive();
                DB.updateDoublePoint({ doublecnt: player.doublecnt, unget_doublecnt: player.unget_doublecnt, roleid: player.roleid })
            }
            if (player.unget_doublecnt >= 60) {
                player.doublecnt += 60;
                player.unget_doublecnt -= 60;
                player.send_notice(`领取60点双倍点数`);
                DB.updateDoublePoint({ doublecnt: player.doublecnt, unget_doublecnt: player.unget_doublecnt, roleid: player.roleid })
                player.getTaskMgr().SendDailyActive();
            }
        }
    }
    //回收物品
    c2s_recycle_item(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            let count = ItemUtil.getBagItemCount(player, data.itemid);
            if (count < data.count) {
                player.send_notice("你背包里没有那么多");
                return;
            }
            player.addItem(data.itemid, -data.count, false);
            player.addMoney(GameUtil.goldKind.guo_Score, data.guoScore, "回收道具")
        }
    }

    // 白名单
    c2s_whitelist_interface(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            Interface.shared.getInterfaceData(player);
        }
    }

    // 结婚
    c2s_get_married(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            if (player.teamid <= 0) {
                player.send_notice("和另一半组队才可以申请！");
                return;
            }
            if (player.isleader == false) {
                player.send_notice("只有队长可以操作！");
                return;
            }
            let team = TeamMgr.shared.getTeamPlayer(player.teamid);
            if (team) {
                if (team.length != 2) {
                    player.send_notice("两个人才可以结婚！");
                    return;;
                }
                Marry.shared.getMarried(player, team);
            }
        }
    }

    c2s_operation_married(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            Marry.shared.operationMarry(player, data.oper);
        }
    }

    //离婚
    c2s_divorce(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            Marry.shared.divorceById(player);
        }
    }

    // 请求提现界面信息
    c2s_information(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            Currency.shared.information(player);
        }
    }

    // 申请提现
    c2s_withdraw(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            Currency.shared.withdraw(player, data);
        }
    }

    // 请求当前现金点爆率
    c2s_mondrop(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player) {
            Currency.shared.mondrop(player);
        }
    }

    c2s_getZhenFaInfo(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            player.getZhenFaInfo()
        }
    }

    c2s_upLevelZhenFa(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            if (!!player.upLevelZhenFa(data.pos, data.level)) {
                player.send('s2c_upLevelZhenFa')
            }
        }
    }

    c2s_equipXwItem(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            player.equipXwItem(data)
        }
    }

    c2s_active_zhenfa_position(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            var code = (!!player.active_zhenfa_position(data) ? 0 : 1)
            player.send("s2c_active_zhenfa_position", {
                code: code
            })
        }
    }

    c2s_xw_normal_succinct(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            player.succinct(data)
        }
    }

    c2s_getXwAttrInfo(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            player.getAttrInfo(data)
        }
    }

    c2s_replaceAttribute(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            player.replaceAttribute(data)
        }
    }

    c2s_getNewAttrInfo(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            player.getNewAttrInfo(data)
        }
    }

    c2s_clearNewAttrInfo(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            player.clearNewAttrInfo()
        }
    }

    c2s_getAttrInfo(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            player.getAllAttrInfo(data.itemID)
        }
    }

    c2s_getBabySkillConfig(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            player.getBabySkillConfig(data)
        }
    }

    c2s_adoptBaby(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            player.adoptBaby(data)
        }
    }

    c2s_babyBattle(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            player.babyBattle(data)
        }
    }
    c2s_babySkillBless(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            player.babySkillBless(data)
        }
    }
    c2s_babySkillUpgrade(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            player.babySkillUpgrade(data)
        }
    }
    c2s_babySkillBattle(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            player.babySkillBattle(data)
        }
    }


    c2s_babyPracticeConfig(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            player.babyPracticeConfig(data)
        }
    }

    c2s_babyPractice(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            player.babyPractice(data)
        }
    }

    c2s_upgradeStar(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            player.upgradeStar(data)
        }
    }

    c2s_getNewStarAttr(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            player.getNewStarAttr(data)
        }
    }

    c2s_replaceStarAttr(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            player.replaceStarAttr(data)
        }
    }

    c2s_equipStar(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (!!player) {
            player.equipStar(data)
        }
    }

    // 请求天梯玩家数据
    c2s_ask_TianTi_info(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player == null) {
            return;
        }
        // 请求排行榜
        if (data.type == 1) {
            TianTi.shared.getTianTidata(player, data.type);
        }
    }
    // 请求天梯兑换
    c2s_TianTi_buy(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player == null) {
            return;
        }
        // 请求天梯兑换
        if (player.tianti_integral >= data.price) {
            player.tianti_integral -= data.price;
            player.addItem(data.itemid, 1, true, `天梯奖励兑换`);
        }
    }
    // 请求天梯奖励数据
    c2s_ask_TianTijiangli_info(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(this.roleId);
        if (player == null) {
            return;
        }
        TianTi.shared.getJiangLidata(player);
    }

    c2s_tianfu_quxiao(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            TianTi.shared.leaveSat(player, player.getTeamId())
        }
    }
    // 天梯报名
    c2s_join_Tianti(data: any) {
        let player = PlayerMgr.shared.getPlayerByRoleId(data.roleid);
        if (player) {
            if (player.isTeamLeader() == false) {
                return;
            }
            // 判断天梯是否开启
            if (TianTi.shared.activity_state == ActivityDefine.activityState.Opening) {  //报名状态
                // if (true) {  //测试用
                let code = TianTi.shared.playerSign(player);
                //     // 成功通知全体成员，失败则通知队长一人
                if (MsgCode.SUCCESS == code) {

                    TeamMgr.shared.broadcast(player.getTeamId(), 's2c_join_tianti_sign', {  //报名成功
                        // code: code,
                        code: 0,
                        //sayState: SatAssembly.shared.activity_state,
                        sayState: 1,
                    });
                } else {
                    this.send('s2c_join_tianti_sign', {//报名失败
                        code: code,
                        sayState: TianTi.shared.activity_state,
                    });
                }
            } else {
                this.send('s2c_join_tianti_sign', {//不在报名时间
                    code: MsgCode.TIANTI_NOT_SIGN_TIME
                });
            }
        }
    }
}