RoServer/RO_Server_Trunk-branch_0.1.39/roserver/game/msg/guild_msg.go

package msg

import (
	"rocommon"
	"rocommon/util"
	"roserver/baseserver/model"
	model2 "roserver/game/model"
	"roserver/serverproto"
	"unicode/utf8"
)

func init() {
	//创建工会
	serverproto.Handle_GAME_CSBuildGuildReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSBuildGuildReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSBuildGuildReq msg=%v", role.GetUUid(), msg)
		nameLen := utf8.RuneCountInString(msg.GuildName)
		if int32(nameLen) < model.GlobalGuildMinNameStringLen || int32(nameLen) > model.GlobalGuildMaxNameStringLen {
			ackMsg := &serverproto.SCBuildGuildAck{}
			ackMsg.Error = int32(serverproto.ErrorCode_ERROR_GUILD_NAME_LEN)
			role.ReplayGate(ackMsg, true)
			return
		}
		bRet := role.(model2.RoleLogicOuter).CheckBuildGuild(msg.GuildName, msg.GuildBadge)
		if bRet == serverproto.ErrorCode_ERROR_OK {
			msg.Uid = role.GetUUid()
			role.(*model2.Role).SendGuild(msg)
		}
	})
	//解散工会
	serverproto.Handle_GAME_CSDisbandGuildReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSDisbandGuildReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSDisbandGuildReq msg=%v", role.GetUUid(), msg)
		guildId := role.(model2.RoleLogicOuter).GetRoleGuildId()
		if guildId != 0 { //有工会才能解散
			msg.GuildId = guildId
			msg.Uid = role.GetUUid()
			role.(*model2.Role).SendGuild(msg)
		} else {
			ackMsg := &serverproto.SCDisbandGuildAck{}
			ackMsg.Error = int32(serverproto.ErrorCode_ERROR_GUILD_NOT_IN_GUILD)
			role.ReplayGate(ackMsg, true)
		}
	})
	//申请加入工会
	serverproto.Handle_GAME_CSApplyGuildReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSApplyGuildReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSApplyGuildReq msg=%v", role.GetUUid(), msg)
		bRet := role.(model2.RoleLogicOuter).CheckApplyGuild(msg.GuildId)
		if bRet {
			msg.Uid = role.GetUUid()
			msg.Level = role.(*model2.Role).GetRoleLevel()
			role.(*model2.Role).SendGuild(msg)
		}
	})
	//退出公会
	serverproto.Handle_GAME_CSQuitGuildReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSQuitGuildReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSQuitGuildReq msg=%v", role.GetUUid(), msg)
		guildId := role.(model2.RoleLogicOuter).GetRoleGuildId()
		if guildId != 0 {
			msg.GuildId = guildId
			msg.Uid = role.GetUUid()
			role.(*model2.Role).SendGuild(msg)
		} else {
			ackMsg := &serverproto.SCQuitGuildAck{}
			ackMsg.Error = int32(serverproto.ErrorCode_ERROR_GUILD_NOT_IN_GUILD)
			role.ReplayGate(ackMsg, true)
		}
	})
	//踢出公会成员
	serverproto.Handle_GAME_CSKickGuildMemberReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSKickGuildMemberReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSKickGuildMemberReq msg=%v", role.GetUUid(), msg)
		guildId := role.(model2.RoleLogicOuter).GetRoleGuildId()
		if guildId != 0 {
			msg.PreUid = role.GetUUid()
			msg.GuildId = guildId
			role.(*model2.Role).SendGuild(msg)
		} else {
			ackMsg := &serverproto.SCKickGuildMemberAck{}
			ackMsg.Error = int32(serverproto.ErrorCode_ERROR_GUILD_NOT_IN_GUILD)
			ackMsg.Uid = msg.Uid
			role.(*model2.Role).ReplayGate(ackMsg, true)
		}
	})
	//提降官职
	serverproto.Handle_GAME_CSChangeMemberTitleReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSChangeMemberTitleReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSChangeMemberTitleReq msg=%v", role.GetUUid(), msg)
		guildId := role.(model2.RoleLogicOuter).GetRoleGuildId()
		if guildId != 0 && msg.Uid != role.GetUUid() { //有公会，不能对自己操作
			msg.GuildId = guildId
			msg.PreUid = role.GetUUid()
			role.(*model2.Role).SendGuild(msg)
		} else {
			ackMsg := &serverproto.SCChangeMemberTitleAck{
				Error: int32(serverproto.ErrorCode_ERROR_FAIL),
			}
			if guildId == 0 {
				ackMsg.Error = int32(serverproto.ErrorCode_ERROR_GUILD_NOT_IN_GUILD)
			}
			role.(*model2.Role).ReplayGate(ackMsg, true)
		}
	})
	//公会申请处理
	serverproto.Handle_GAME_CSApplyInfoHandleReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSApplyInfoHandleReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSApplyInfoHandleReq msg=%v", role.GetUUid(), msg)
		bRet := role.(model2.RoleLogicOuter).CheckApplyInfo(msg)
		if bRet == serverproto.ErrorCode_ERROR_OK {
			msg.GuildId = role.(model2.RoleLogicOuter).GetRoleGuildId()
			msg.Uid = role.GetUUid()
			role.(*model2.Role).SendGuild(msg)
		}
	})
	//公会信息请求
	serverproto.Handle_GAME_CSGuildInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildInfoReq msg=%v", role.GetUUid(), msg)
		msg.Uid = role.GetUUid()
		role.(*model2.Role).SendGuild(msg)
	})

	//自己公会信息请求
	serverproto.Handle_GAME_CSGetSelfGuildInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGetSelfGuildInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGetSelfGuildInfoReq msg=%v", role.GetUUid(), msg)
		guildId := role.(model2.RoleLogicOuter).GetRoleGuildId()
		if guildId != 0 {
			msg.GuildId = guildId
			msg.Uid = role.GetUUid()
			role.(*model2.Role).SendGuild(msg)
		} else {
			ackMsg := &serverproto.SCGetSelfGuildInfoAck{
				Error: int32(serverproto.ErrorCode_ERROR_GUILD_NOT_IN_GUILD),
			}
			role.(*model2.Role).ReplayGate(ackMsg, true)
		}
	})

	//修改公户名称
	serverproto.Handle_GAME_CSGuildRenameReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildRenameReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildRenameReq msg=%v", role.GetUUid(), msg)

		bRet := role.(model2.RoleLogicOuter).CheckGuildRename(msg.GuildName)
		if bRet != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCGuildRenameAck{
				Error: int32(bRet),
			}
			role.(*model2.Role).ReplayGate(ackMsg, true)
			return
		}
		msg.GuildId = role.(model2.RoleLogicOuter).GetRoleGuildId()
		msg.Uid = role.GetUUid()
		role.(*model2.Role).SendGuild(msg)
	})

	//修改公户公告
	serverproto.Handle_GAME_CSGuildReNoticeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildReNoticeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildReNoticeReq msg=%v", role.GetUUid(), msg)
		bRet := role.(model2.RoleLogicOuter).CheckGuildRenotice(msg.GuildNotice)
		if bRet == serverproto.ErrorCode_ERROR_OK {
			msg.GuildId = role.(model2.RoleLogicOuter).GetRoleGuildId()
			msg.Uid = role.GetUUid()
			role.(*model2.Role).SendGuild(msg)
		} else {
			ackMsg := &serverproto.SCGuildReNoticeAck{
				Error:       int32(bRet),
				GuildNotice: msg.GuildNotice,
			}
			role.(*model2.Role).ReplayGate(ackMsg, true)
		}
	})

	//修改工会招募信息
	serverproto.Handle_GAME_CSSetGuildInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSSetGuildInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSSetGuildInfoReq msg=%v", msg)
		bRet := role.(model2.RoleLogicOuter).CheckGuildModifyInfo(msg)
		if bRet != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCSetGuildInfoAck{}
			ackMsg.Error = int32(bRet)
			ackMsg.JoinLevel = msg.JoinLevel
			ackMsg.JoinType = msg.JoinType
			ackMsg.GuildBadge = msg.GuildBadge
			role.(*model2.Role).ReplayGate(ackMsg, true)
			return
		}
		msg.GuildId = role.(model2.RoleLogicOuter).GetRoleGuildId()
		msg.Uid = role.GetUUid()
		role.(*model2.Role).SendGuild(msg)
	})

	serverproto.Handle_GAME_CSGuildMemberInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildMemberInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildMemberInfoReq msg=%v", role.GetUUid(), msg)
		role.(*model2.Role).SendGuild(msg)
	})

	//推荐公会请求
	serverproto.Handle_GAME_CSRecommendGuildInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSRecommendGuildInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSRecommendGuildInfoReq msg=%v", role.GetUUid(), msg)
		msg.Uid = role.GetUUid()
		msg.ReqCount = role.(*model2.Role).GetRoleGuild().GetRecommendCount()
		role.(*model2.Role).SendGuild(msg)
	})

	//玩家上线，一定要请求公会信息的。
	serverproto.Handle_GAME_CSOnlinePlayerGuildReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSOnlinePlayerGuildReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSOnlinePlayerGuildReq msg=%v", role.GetUUid(), msg)
		reqMsg := &serverproto.SSOnlineGuildInfoReq{}
		reqMsg.Uid = role.(*model2.Role).GetUUid()
		reqMsg.GuildId = role.(model2.RoleLogicOuter).GetRoleGuildId()
		reqMsg.IsRelogin = false
		reqMsg.DemonFightTime = role.(*model2.Role).GetRoleGuild().GetDemonFightTime()

		role.(*model2.Role).SendGuild(reqMsg)
	})

	//查找公会
	serverproto.Handle_GAME_CSSearchGuildReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSSearchGuildReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSSearchGuildReq msg=%v", role.GetUUid(), msg)
		nameLen := utf8.RuneCountInString(msg.SearchString)
		if int32(nameLen) < model.GlobalGuildMinSearchStringLen || int32(nameLen) > model.GlobalGuildMaxSearchStringLen {
			ackMsg := &serverproto.SCSearchGuildAck{}
			ackMsg.Error = int32(serverproto.ErrorCode_ERROR_GUILD_NAME_LEN)
			ackMsg.SearchString = msg.SearchString
			role.ReplayGate(ackMsg, true)
			return
		}
		msg.Uid = role.GetUUid()
		role.(*model2.Role).SendGuild(msg)
	})

	//查找公会
	serverproto.Handle_GAME_CSGuildApplyDataReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildApplyDataReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildApplyDataReq msg=%v", role.GetUUid(), msg)
		//todo wangzhaocan  检查是否有公会

		msg.Uid = role.GetUUid()
		msg.GuildId = role.(model2.RoleLogicOuter).GetRoleGuildId()
		role.(*model2.Role).SendGuild(msg)
	})

	serverproto.Handle_GAME_CSGuildLogInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildLogInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildLogInfoReq msg=%v", role.GetUUid(), msg)
		guildId := role.(model2.RoleLogicOuter).GetRoleGuildId()
		if guildId != 0 {
			msg.GuildId = guildId
			role.(*model2.Role).SendGuild(msg)
		} else {
			ackMsg := &serverproto.SCGuildLogInfoAck{}
			ackMsg.IsEnd = true
			role.ReplayGate(ackMsg, true)
		}
	})

	//请求公会boss
	serverproto.Handle_GAME_CSGuildBossInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBossInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBossInfoReq msg=%v", role.GetUUid(), msg)
		guildId := role.(model2.RoleLogicOuter).GetRoleGuildId()
		if guildId != 0 {
			msg.GuildId = guildId
			role.(*model2.Role).SendGuild(msg)
		} else {
			ackMsg := &serverproto.SCGuildBossInfoAck{}
			ackMsg.Error = int32(serverproto.ErrorCode_ERROR_GUILD_NOT_IN_GUILD)
			role.ReplayGate(ackMsg, true)
		}
	})

	//公会BOSS日志请求
	serverproto.Handle_GAME_CSGuildBossLogReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBossLogReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBossLogReq msg=%v", role.GetUUid(), msg)

		guildId := role.(model2.RoleLogicOuter).GetRoleGuildId()
		if guildId != 0 {
			msg.GuildId = guildId
			role.(*model2.Role).SendGuild(msg)
		} else {
			ackMsg := &serverproto.SCGuildBossLogAck{}
			ackMsg.Error = int32(serverproto.ErrorCode_ERROR_GUILD_NOT_IN_GUILD)
			role.ReplayGate(ackMsg, true)
		}
	})

	//公会boss挑战
	serverproto.Handle_GAME_CSGuildBossChallengeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBossChallengeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBossLogReq msg=%v", role.GetUUid(), msg)

		bRet := role.(model2.RoleLogicOuter).CheckGuildBossChallenge(msg.BossId, msg.Damage, msg.BattleTime)
		if bRet == serverproto.ErrorCode_ERROR_OK {
			msg.GuildId = role.(model2.RoleLogicOuter).GetRoleGuildId()
			msg.Uid = role.GetUUid()
			role.(*model2.Role).SendGuild(msg)
		} else {
			ackMsg := &serverproto.SCGuildBossChallengeAck{}
			ackMsg.Error = int32(bRet)
			role.ReplayGate(ackMsg, true)
		}
	})

	//公会boss召唤
	serverproto.Handle_GAME_CSGuildBossSummonReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBossSummonReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBossSummonReq msg=%v", role.GetUUid(), msg)

		guildId := role.(model2.RoleLogicOuter).GetRoleGuildId()
		if guildId != 0 {
			msg.GuildId = role.(model2.RoleLogicOuter).GetRoleGuildId()
			msg.Uid = role.GetUUid()
			role.(*model2.Role).SendGuild(msg)
		} else {
			ackMsg := &serverproto.SCGuildBossSummonAck{}
			ackMsg.Error = int32(serverproto.ErrorCode_ERROR_GUILD_NOT_IN_GUILD)
			role.ReplayGate(ackMsg, true)
		}
	})

	//大师奖励
	serverproto.Handle_GAME_CSGuildBossExtraRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBossExtraRewardReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBossExtraRewardReq msg=%v", role.GetUUid(), msg)

		guildId := role.(model2.RoleLogicOuter).GetRoleGuildId()
		if guildId != 0 {
			msg.GuildId = role.(model2.RoleLogicOuter).GetRoleGuildId()
			role.(*model2.Role).SendGuild(msg)
		} else {
			ackMsg := &serverproto.SCGuildBossExtraRewardAck{}
			ackMsg.Error = int32(serverproto.ErrorCode_ERROR_GUILD_NOT_IN_GUILD)
			role.ReplayGate(ackMsg, true)
		}
	})

	//======================================================= 从guildserver过来的消息 =======================================================

	serverproto.Handle_GAME_SCBuildGuildAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCBuildGuildAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCBuildGuildAck msg=%v", role.GetUUid(), msg)
		if msg.Error == int32(serverproto.ErrorCode_ERROR_OK) {
			role.(*model2.Role).GetRoleGuild().BuildGuildSuccess(msg.GuildBrief)
		}
		role.ReplayGate(msg, true)
	})

	//解散公会
	serverproto.Handle_GAME_SCDisbandGuildAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCDisbandGuildAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCDisbandGuildAck msg=%v", role.GetUUid(), msg)
		if msg.Error == int32(serverproto.ErrorCode_ERROR_OK) {
			role.(*model2.Role).GetRoleGuild().DisbandGuild()
		}
		role.ReplayGate(msg, true)
	})

	//申请加入公会返回
	serverproto.Handle_GAME_SCApplyGuildAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCApplyGuildAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCApplyGuildAck msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})

	//离开公会
	serverproto.Handle_GAME_SCQuitGuildAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCQuitGuildAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCQuitGuildAck msg=%v", role.GetUUid(), msg)

		if msg.Error == int32(serverproto.ErrorCode_ERROR_OK) {
			role.(*model2.Role).GetRoleGuild().QuitGuild()
		}
		role.ReplayGate(msg, true)
	})

	//踢除玩家
	serverproto.Handle_GAME_SCKickGuildMemberAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCKickGuildMemberAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCKickGuildMemberAck msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})

	//变更玩家官职
	serverproto.Handle_GAME_SCChangeMemberTitleAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCChangeMemberTitleAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCChangeMemberTitleAck msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})

	//设置公会信息返回包
	serverproto.Handle_GAME_SCSetGuildInfoAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCSetGuildInfoAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCSetGuildInfoAck msg=%v", role.GetUUid(), msg)

		role.ReplayGate(msg, true)
	})

	//Guild返回请求公会消息
	serverproto.Handle_GAME_SCGuildInfoAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildInfoAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildInfoAck msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})

	//Guild返回请求公会消息
	serverproto.Handle_GAME_SCGetSelfGuildInfoAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGetSelfGuildInfoAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGetSelfGuildInfoAck msg=%v", role.GetUUid(), msg)
		if msg.Error == int32(serverproto.ErrorCode_ERROR_OK) {
			msg.RoleGuild = role.(*model2.Role).GetRoleGuild().GetGuildInfo()
		}

		role.ReplayGate(msg, true)
	})

	//Guild返回请求公会消息
	serverproto.Handle_GAME_SCApplyInfoHandleAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCApplyInfoHandleAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCApplyInfoHandleAck msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})

	//客户端上线请求公会相关
	serverproto.Handle_GAME_SSOnlineGuildInfoAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSOnlineGuildInfoAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			util.InfoF("uid=%v receive SSOnlineGuildInfoAck role not found")
			return
		}
		util.InfoF("uid=%v receive SSOnlineGuildInfoAck msg=%v", role.GetUUid(), msg)

		if msg.Data != nil && msg.Data.Brief != nil {
			role.(*model2.Role).GetRoleGuild().SetOnlineGuildInfo(msg.Data.Brief.GuildId, msg.Data.Brief.GuildName)
		} else if msg.Data == nil {
			role.(*model2.Role).GetRoleGuild().SetOnlineGuildInfo(0, "")
		}

		ackMsg := &serverproto.SCOnlinePlayerGuildAck{}
		ackMsg.InGuildBattle = msg.InGuildBattle
		ackMsg.Data = msg.Data
		ackMsg.NextJoin = msg.NextJoin
		ackMsg.MsgRec = msg.MsgRec
		//	ackMsg.Boss = msg.Boss
		bRet := role.(*model2.Role).GetRoleGuild().HasBattleCount(msg)
		ackMsg.Boss = bRet
		ackMsg.NextJoin = role.(*model2.Role).GetRoleGuild().GetNextJoin()
		role.ReplayGate(ackMsg, true)

		if msg.GuildSys != nil {
			ntfMsg := &serverproto.SCSystemMessageNtf{}
			ntfMsg.SysMsg = append(ntfMsg.SysMsg, msg.GuildSys)
			role.ReplayGate(ntfMsg, true)
		}
	})

	//修改公户名称
	serverproto.Handle_GAME_SCGuildRenameAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildRenameAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildRenameAck msg=%v", role.GetUUid(), msg)
		if msg.Error == int32(serverproto.ErrorCode_ERROR_OK) {
			role.(model2.RoleLogicOuter).OnChangeGuileNameSuccess()
		}
		role.ReplayGate(msg, true)
	})

	//修改公户公告
	serverproto.Handle_GAME_SCGuildReNoticeAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildReNoticeAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildReNoticeAck msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})

	//公会成员信息返回
	serverproto.Handle_GAME_SCGuildMemberInfoAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildMemberInfoAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildMemberInfoAck msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})

	//查询工会结果返回
	serverproto.Handle_GAME_SCSearchGuildAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCSearchGuildAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCSearchGuildAck msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})

	//推荐公会列表返回
	serverproto.Handle_GAME_SCRecommendGuildInfoAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCRecommendGuildInfoAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCRecommendGuildInfoAck msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})

	//公会信息通知（有玩家直接加入公会，或者会长批准入会）
	serverproto.Handle_GAME_SCApplyInfoHandleNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCApplyInfoHandleNtf)
		role := model2.RoleMag.GetRoleFromUUid(msg.Uid)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCApplyInfoHandleNtf msg=%v", role.GetUUid(), msg)
		if msg.ApplyResult == 1 { //1:Guild_Apply_Accept
			role.(*model2.Role).GetRoleGuild().SetOnlineGuildInfo(msg.GuildId, msg.Data.Brief.GuildName)
		}
		role.ReplayGate(msg, true)
	})

	//公会申请列表返回
	serverproto.Handle_GAME_SCGuildApplyDataAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildApplyDataAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildApplyDataAck msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})

	//公会日志列表返回
	serverproto.Handle_GAME_SCGuildLogInfoAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildLogInfoAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildLogInfoAck msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})

	//更改公会成员头衔返回
	serverproto.Handle_GAME_SCChangeMemberTitleNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCChangeMemberTitleNtf)
		role := model2.RoleMag.GetRoleFromUUid(msg.Uid)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCChangeMemberTitleNtf msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})

	//踢出玩家通知（通知到被踢玩家）
	serverproto.Handle_GAME_SCKickGuildMemberNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCKickGuildMemberNtf)
		role := model2.RoleMag.GetRoleFromUUid(msg.Uid)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCKickGuildMemberNtf msg=%v", role.GetUUid(), msg)
		role.(*model2.Role).GetRoleGuild().SetOnlineGuildInfo(0, "")
		role.ReplayGate(msg, true)
	})

	//boss信息
	serverproto.Handle_GAME_SCGuildBossInfoAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildBossInfoAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildBossInfoAck msg=%v", role.GetUUid(), msg)
		role.(*model2.Role).GetRoleGuild().SetFightCount(msg)
		role.ReplayGate(msg, true)
	})

	//boss日志
	serverproto.Handle_GAME_SCGuildBossLogAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildBossLogAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildBossLogAck msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})

	//boss挑战
	serverproto.Handle_GAME_SCGuildBossChallengeAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildBossChallengeAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildBossChallengeAck msg=%v", role.GetUUid(), msg)
		if msg.Error == int32(serverproto.ErrorCode_ERROR_OK) {
			role.(*model2.Role).GetRoleGuild().GuildBossFightSuccess(msg)
		}
		role.ReplayGate(msg, true)
	})

	//boss召唤
	serverproto.Handle_GAME_SCGuildBossSummonAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildBossSummonAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildBossSummonAck msg=%v", role.GetUUid(), msg)
		if msg.Error == int32(serverproto.ErrorCode_ERROR_OK) {
			nCount := role.(*model2.Role).GetRoleGuild().GetBossFightCount(msg.BossId)
			msg.FightCount = nCount
		}
		role.ReplayGate(msg, true)
	})

	//公会boss额外奖励
	serverproto.Handle_GAME_SCGuildBossExtraRewardAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildBossExtraRewardAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildBossExtraRewardAck msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})

	//公会boss额外奖励
	serverproto.Handle_GAME_SSGuildBossRefreshNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGuildBossRefreshNtf)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SSGuildBossRefreshNtf msg=%v", role.GetUUid(), msg)
		role.(*model2.Role).GetRoleGuild().BossRefreshData(msg)
	})

	//公会名字修改
	serverproto.Handle_GAME_SCGuildNameChangeNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildNameChangeNtf)
		role := model2.RoleMag.GetRoleFromUUid(msg.Uid)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildNameChangeNtf msg=%v", role.GetUUid(), msg)
		role.(*model2.Role).GetRoleGuild().GuildNameChange(msg.GuildId, msg.GuildName)
		role.ReplayGate(msg, true)
	})

	//////公会战
	//公会战贡献点
	serverproto.Handle_GAME_CSGuildBattleCPRankReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBattleCPRankReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBattleCPRankReq msg=%v", role.GetUUid(), msg)

		//请求消息时间拦截（防止频繁请求）
		bRet := role.(*model2.Role).GetRoleGuild().CheckReqTime()
		if !bRet {
			return
		}

		//转发到公会服务器
		reqMsg := &serverproto.SSGuildBattleCPRankReq{}
		reqMsg.Uid = role.GetUUid()
		reqMsg.GuildId = uint64(role.(model2.RoleLogicOuter).GetRoleGuildId())
		role.(*model2.Role).SendGuild(reqMsg)
	})
	serverproto.Handle_GAME_SSGuildBattleCPRankAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGuildBattleCPRankAck)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SSGuildBattleCPRankAck msg=%v", role.GetUUid(), msg)

		//转发到公会服务器
		ackMsg := &serverproto.SCGuildBattleCPRankAck{}
		ackMsg.Error = int32(serverproto.ErrorCode_ERROR_OK)
		ackMsg.CpList = msg.CpList
		ackMsg.SelfGuildRank = msg.SelfGuildRank
		ackMsg.SelfGuildCp = msg.SelfGuildCp
		role.(*model2.Role).ReplayGate(ackMsg, true)
	})

	//公会战对阵表
	serverproto.Handle_GAME_CSGuildBattleCountPartReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBattleCountPartReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBattleCountPartReq msg=%v", role.GetUUid(), msg)

		//请求消息时间拦截（防止频繁请求）
		bRet := role.(*model2.Role).GetRoleGuild().CheckReqTime()
		if !bRet {
			return
		}
		//转发到公会服务器
		reqMsg := &serverproto.SSGuildBattleCountPartReq{}
		reqMsg.Uid = role.GetUUid()
		role.(*model2.Role).SendGuild(reqMsg)
	})
	serverproto.Handle_GAME_SSGuildBattleCountPartAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGuildBattleCountPartAck)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SSGuildBattleCountPartAck msg=%v", role.GetUUid(), msg)

		//转发到公会服务器
		ackMsg := &serverproto.SCGuildBattleCountPartAck{}
		ackMsg.CurStge = msg.CurStge
		ackMsg.Champion = msg.Champion
		if msg.Table != nil {
			ackMsg.Data = append(ackMsg.Data, msg.Table.Data...)
		}
		ackMsg.TournamentPrepare = msg.TournamentPrepare
		ackMsg.TournamentBegin = msg.TournamentBegin
		ackMsg.TournamentEnd = msg.TournamentEnd
		ackMsg.SemifinalsPrepare = msg.SemifinalsPrepare
		ackMsg.SemifinalsBegin = msg.SemifinalsBegin
		ackMsg.SemifinalsEnd = msg.SemifinalsEnd
		ackMsg.FinalsPrepare = msg.FinalsPrepare
		ackMsg.FinalsBegin = msg.FinalsBegin
		ackMsg.FinalsEnd = msg.FinalsEnd
		role.(*model2.Role).ReplayGate(ackMsg, true)
	})

	//公会战查看界面数据请求
	serverproto.Handle_GAME_CSGuildBattleMvpInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBattleMvpInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBattleMvpInfoReq msg=%v", role.GetUUid(), msg)

		//转发到公会服务器
		reqMsg := &serverproto.SSGuildBattleMvpInfoReq{}
		role.(*model2.Role).SendGuild(reqMsg)
	})
	serverproto.Handle_GAME_SSGuildBattleMvpInfoAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGuildBattleMvpInfoAck)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SSGuildBattleMvpInfoAck msg=%v", role.GetUUid(), msg)

		//转发到公会服务器
		ackMsg := &serverproto.SCGuildBattleMvpInfoAck{}
		ackMsg.GuildBattleIdx = msg.GuildBattleIdx
		ackMsg.Error = msg.Error
		ackMsg.Detail = msg.Detail
		ackMsg.CountPart = msg.CountPart
		role.(*model2.Role).ReplayGate(ackMsg, true)
	})

	//公会战MVP详情请求
	serverproto.Handle_GAME_CSGuildBattleMvpDetailReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBattleMvpDetailReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBattleMvpDetailReq msg=%v", role.GetUUid(), msg)

		//转发到公会服务器
		reqMsg := &serverproto.SSGuildBattleMvpDetailReq{}
		role.(*model2.Role).SendGuild(reqMsg)
	})
	serverproto.Handle_GAME_SSGuildBattleMvpDetailAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGuildBattleMvpDetailAck)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SSGuildBattleMvpDetailAck msg=%v", role.GetUUid(), msg)

		//转发到公会服务器
		ackMsg := &serverproto.SCGuildBattleMvpDetailAck{}
		role.(*model2.Role).ReplayGate(ackMsg, true)
	})

	//获取对阵双方信息(打开界面时的信息)
	serverproto.Handle_GAME_CSGuildBattleInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBattleInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBattleInfoReq msg=%v", role.GetUUid(), msg)
		if msg.GuildBattleIdx > 7 || msg.GuildBattleIdx <= 0 {
			ackMsg := &serverproto.SCGuildBattleInfoAck{}
			ackMsg.Error = int32(serverproto.ErrorCode_ERROR_FAIL)
			role.ReplayGate(ackMsg, true)
			return
		}

		msg.SelfGuildId = uint64(role.(model2.RoleLogicOuter).GetRoleGuildId())
		role.(*model2.Role).SendGuild(msg)
	})
	//from guild
	serverproto.Handle_GAME_SCGuildBattleInfoAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildBattleInfoAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildBattleInfoAck msg=%v", role.GetUUid(), msg)
		msg.BuyChallengeNum = role.(*model2.Role).GetRoleGuild().GetBuyChallengeNum()
		role.ReplayGate(msg, true)
	})
	//设置自动购买，复活CD(数据变更通过SCGuildBattleInfoNtf)
	serverproto.Handle_GAME_CSGuildBattleSettingReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBattleSettingReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBattleSettingReq msg=%v", role.GetUUid(), msg)
		if msg.GuildBattleIdx > 7 || msg.GuildBattleIdx <= 0 {
			ackMsg := &serverproto.SCGuildBattleSettingAck{}
			ackMsg.Error = int32(serverproto.ErrorCode_ERROR_FAIL)
			role.ReplayGate(ackMsg, true)
			return
		}

		msg.SelfGuildId = uint64(role.(model2.RoleLogicOuter).GetRoleGuildId())
		role.(*model2.Role).SendGuild(msg)
	})
	//from guild
	serverproto.Handle_GAME_SCGuildBattleSettingAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildBattleSettingAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildBattleSettingAck msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})
	//挑战次数手动购买
	serverproto.Handle_GAME_CSGuildBattleBuyChallengeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBattleBuyChallengeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		util.InfoF("uid=%v receive CSGuildBattleBuyChallengeReq msg=%v", role.GetUUid(), msg)
		role.(*model2.Role).GetRoleGuild().GuildBattleBuyChallengeNum(msg)
	})
	//from guild
	serverproto.Handle_GAME_SCGuildBattleBuyChallengeAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildBattleBuyChallengeAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildBattleBuyChallengeAck msg=%v", role.GetUUid(), msg)
		if msg.Error == int32(serverproto.ErrorCode_ERROR_OK) {
			role.(*model2.Role).GetRoleGuild().AddBuyChallengeCount(true)
			msg.BuyChallengeNum = role.(*model2.Role).GetRoleGuild().GetBuyChallengeNum()
		}
		role.ReplayGate(msg, true)
	})
	//手动重置复活CD
	serverproto.Handle_GAME_CSGuildBattleRebornReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBattleRebornReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBattleRebornReq msg=%v", role.GetUUid(), msg)

		role.(*model2.Role).GetRoleGuild().GuildBattleResetReborn(msg)
	})
	//from guild
	serverproto.Handle_GAME_SCGuildBattleRebornAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildBattleRebornAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBattleRebornAck msg=%v", role.GetUUid(), msg)
		role.(*model2.Role).GetRoleGuild().OnGuildBattleResetReborn(msg)
	})
	//战斗排行(1积分排行/2击杀排行)
	serverproto.Handle_GAME_CSGuildBattleRankListReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBattleRankListReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBattleRankListReq msg=%v", role.GetUUid(), msg)
		if msg.PageIdx < 0 || msg.PageIdx > 20 || msg.GuildBattleIdx <= 0 || msg.GuildBattleIdx > 7 {
			ackMsg := &serverproto.SCGuildBattleRankListAck{
				Error: int32(serverproto.ErrorCode_ERROR_FAIL),
			}
			role.ReplayGate(ackMsg, true)
			return
		}
		role.(*model2.Role).SendGuild(msg)
	})
	//from guild
	serverproto.Handle_GAME_SCGuildBattleRankListAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildBattleRankListAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildBattleRankListAck msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})
	//获取位置信息,上限20
	serverproto.Handle_GAME_CSGuildBattlePosIdxListReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBattlePosIdxListReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBattlePosIdxListReq msg=%v", role.GetUUid(), msg)
		if msg.GuildBattleIdx <= 0 || msg.GuildBattleIdx > 7 || len(msg.PosIdxList) > 25 {
			ackMsg := &serverproto.SCGuildBattlePosIdxListAck{
				Error: int32(serverproto.ErrorCode_ERROR_FAIL),
			}
			role.ReplayGate(ackMsg, true)
			return
		}
		role.(*model2.Role).SendGuild(msg)
	})
	//from guild
	serverproto.Handle_GAME_SCGuildBattlePosIdxListAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildBattlePosIdxListAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildBattlePosIdxListAck msg=%v", role.GetUUid(), msg)

		role.ReplayGate(msg, true)
	})
	//占领记录
	serverproto.Handle_GAME_CSGuildBattleLogReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBattleLogReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBattleLogReq msg=%v", role.GetUUid(), msg)
		if msg.GuildBattleIdx <= 0 || msg.GuildBattleIdx > 7 {
			ackMsg := &serverproto.SCGuildBattleLogAck{
				Error: int32(serverproto.ErrorCode_ERROR_FAIL),
			}
			role.ReplayGate(ackMsg, true)
			return
		}
		role.(*model2.Role).SendGuild(msg)
	})
	//from guild
	serverproto.Handle_GAME_SCGuildBattleLogAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildBattleLogAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildBattleLogAck msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})
	//挑战占位
	serverproto.Handle_GAME_CSGuildBattleChallengeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBattleChallengeReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBattleChallengeReq msg=%v", role.GetUUid(), msg)
		if msg.GuildBattleIdx <= 0 || msg.GuildBattleIdx > 7 {
			ackMsg := &serverproto.SCGuildBattleChallengeAck{
				Error: int32(serverproto.ErrorCode_ERROR_FAIL),
			}
			role.ReplayGate(ackMsg, true)
			return
		}
		ret := role.(*model2.Role).GetRoleGuild().GuildBattleChallengePre(msg.GuildBattleIdx, msg.PosIdx)
		if ret != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCGuildBattleChallengeAck{
				Error: int32(ret),
			}
			role.ReplayGate(ackMsg, true)
		}
	})
	//from guild
	serverproto.Handle_GAME_SSGuildBattleChallengeAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGuildBattleChallengeAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SSGuildBattleChallengeAck msg=%v", role.GetUUid(), msg)
		role.(*model2.Role).GetRoleGuild().OnGuildBattleChallengePre(msg)
	})
	//战斗结果通知
	serverproto.Handle_GAME_CSGuildBattleChallengeResultReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBattleChallengeResultReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBattleChallengeResultReq msg=%v", role.GetUUid(), msg)
		if msg.GuildBattleIdx <= 0 || msg.GuildBattleIdx > 7 {
			ackMsg := &serverproto.SCGuildBattleChallengeResultAck{
				Error: int32(serverproto.ErrorCode_ERROR_FAIL),
			}
			role.ReplayGate(ackMsg, true)
			return
		}
		role.(*model2.Role).GetRoleGuild().GuildBattleChallengeResult(msg)
	})
	//from guild
	serverproto.Handle_GAME_SCGuildBattleChallengeResultAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildBattleChallengeResultAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildBattleChallengeResultAck msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})
	//保持战斗状态消息通知(60s内未收到消息判定为失败)
	serverproto.Handle_GAME_CSGuildBattleChallengePingReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBattleChallengePingReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBattleChallengePingReq msg=%v", role.GetUUid(), msg)
		role.(*model2.Role).GetRoleGuild().GuildBattleChallengePint(msg)
	})
	serverproto.Handle_GAME_SCGuildBattleChallengePingAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildBattleChallengePingAck)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildBattleChallengePingAck msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})
	//客户端刷新最新pk数据(道场数量/积分数量)
	serverproto.Handle_GAME_CSGuildBattlePKDataReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBattlePKDataReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBattlePKDataReq msg=%v", role.GetUUid(), msg)
		if msg.GuildBattleIdx <= 0 || msg.GuildBattleIdx > 7 {
			ackMsg := &serverproto.SCGuildBattlePKDataAck{
				Error: int32(serverproto.ErrorCode_ERROR_FAIL),
			}
			role.ReplayGate(ackMsg, true)
			return
		}

		role.(*model2.Role).SendGuild(msg)
	})
	//客户端购买buff
	serverproto.Handle_GAME_CSGuildBattleBuyBuffReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildBattleBuyBuffReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildBattleBuyBuffReq msg=%v", role.GetUUid(), msg)
		if msg.GuildBattleIdx <= 0 || msg.GuildBattleIdx > 7 {
			ackMsg := &serverproto.SCGuildBattleBuyBuffAck{
				Error: int32(serverproto.ErrorCode_ERROR_FAIL),
			}
			role.ReplayGate(ackMsg, true)
			return
		}
		reqMsg := &serverproto.SSGuildBattleBuyBuffReq{
			GuildBattleIdx: msg.GuildBattleIdx,
			BuffIdList:     msg.BuffIdList,
			Uid:            role.GetUUid(),
			GuildId:        role.(model2.RoleLogicOuter).GetRoleGuildId(),
			TotalGold:      role.(*model2.Role).GetResNum(int32(serverproto.ResType_Res_Rmb)),
		}

		role.(*model2.Role).SendGuild(reqMsg)
	})
	////客户端购买buff（rank返回）
	serverproto.Handle_GAME_SSGuildBattleBuyBuffAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGuildBattleBuyBuffAck)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SSGuildBattleBuyBuffAck msg=%v", role.GetUUid(), msg)

		if msg.Error == int32(serverproto.ErrorCode_ERROR_OK) {
			//扣除金币
			role.(*model2.Role).GetRoleGuild().RemoveBuyBuffGold(msg.NeedRes)
		}
		ackMsg := &serverproto.SCGuildBattleBuyBuffAck{
			Error:          msg.Error,
			SelfData:       msg.SelfData,
			GuildBattleIdx: msg.GuildBattleIdx,
		}
		role.(*model2.Role).ReplayGate(ackMsg, true)
	})
	//from guild
	serverproto.Handle_GAME_SCGuildBattlePKDataAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildBattlePKDataAck)
		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildBattlePKDataAck msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})
	//from guild(战场中玩家数据变更通知)
	serverproto.Handle_GAME_SCGuildBattleDataChangeNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildBattleDataChangeNtf)
		util.InfoF("uid=%v receive SCGuildBattleDataChangeNtf msg=%v", cliId.SessID, msg)

		targetRole := model2.RoleMag.GetRoleFromUUid(msg.NtfUid)
		if targetRole == nil {
			targetRole = model2.RoleMag.GetRoleFromOffline(msg.NtfUid)
		}
		if targetRole != nil {
			targetRole.ReplayGate(msg, true)
		} else if !msg.FromSocial {
			role := model2.RoleMag.GetRole(cliId)
			if role == nil {
				return
			}
			//通知的是自己
			if role.GetUUid() != msg.NtfUid {
				role.(*model2.Role).SendSocial(msg)
			}
		}
	})

	//
	serverproto.Handle_GAME_SSGuildBattleStageChangeNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGuildBattleStageChangeNtf)
		util.InfoF("uid=%v receive SSGuildBattleStageChangeNtf msg=%v", cliId.SessID, msg)

		//通知在线玩家活动开始
		model2.RoleMag.GuildBattleBeginNtf(msg.InGuildBattle)
	})

	//发送公会战排名奖励
	serverproto.Handle_GAME_SSGuildBattleRewardNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGuildBattleRewardNtf)
		util.ErrorF("uid=%v receive SSGuildBattleRewardNtf msg=%v", cliId.SessID, msg)

		if msg.GuildPre != 0 {
			newCliId := &model.ClientID{
				SessID: msg.GuildPre,
			}
			role := model2.RoleMag.GetRole(*newCliId)
			if role != nil {
				round := role.(*model2.Role).GetRoleGuild().GetGuildBattleRewardRound()
				if round < msg.GuildRound {
					//获取奖励列表
					reward, ok := model.GuildBattleRankReward[msg.RewardType]
					if ok {
						role.(model2.RoleLogicOuter).AddMail1(model.GlobalMailGuildBattlePreReward, int32(serverproto.MailType_MailType_GuildBattle_Pre),
							reward.LeaderRewardList, []int32{msg.RewardType}, "", "")
						//todo wangzhaocan 设置领奖标记
						role.(*model2.Role).GetRoleGuild().SetGuildBattleRewardRound(msg.GuildRound)
					}
				}
			}
		}
		reward, ok := model.GuildBattleRankReward[msg.RewardType]
		if ok {
			for _, uid := range msg.UidList {
				newCliId := &model.ClientID{
					SessID: uid,
				}
				role := model2.RoleMag.GetRole(*newCliId)
				if role == nil {
					continue
				}
				round := role.(*model2.Role).GetRoleGuild().GetGuildBattleRewardRound()
				if round < msg.GuildRound {
					role.(model2.RoleLogicOuter).AddMail1(model.GlobalMailGuildBattleMemReward, int32(serverproto.MailType_MailType_GuildBattle_Member),
						reward.MemberRewardList, []int32{msg.RewardType}, "", "")

					//todo wangzhaocan 设置领奖标记
					role.(*model2.Role).GetRoleGuild().SetGuildBattleRewardRound(msg.GuildRound)
				}
			}
		}
	})

	//玩家上线，请求未发送的邮件奖励
	serverproto.Handle_GAME_SSGuildBattleOnlineGetRewardAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGuildBattleOnlineGetRewardAck)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SSGuildBattleOnlineGetRewardAck msg=%v", cliId.SessID, msg)

		for _, data := range msg.RoundReward {
			reward, ok := model.GuildBattleRankReward[data.RewardType]
			if ok {
				if data.IsPre == true {
					role.(model2.RoleLogicOuter).AddMail1(model.GlobalMailGuildBattlePreReward, int32(serverproto.MailType_MailType_GuildBattle_Pre),
						reward.LeaderRewardList, []int32{data.RewardType}, "", "")
				} else {
					role.(model2.RoleLogicOuter).AddMail1(model.GlobalMailGuildBattleMemReward, int32(serverproto.MailType_MailType_GuildBattle_Member),
						reward.MemberRewardList, []int32{data.RewardType}, "", "")
				}
				//设领奖标记
				role.(*model2.Role).GetRoleGuild().SetGuildBattleRewardRound(msg.CurBattleRound)
			}
		}

		//发送积分奖励
		for _, data := range msg.ScoreMvp {
			reward, ok := model.GuildBattleScoreMvpReward[data.RewardType]
			if ok {
				role.(model2.RoleLogicOuter).AddMail1(model.GlobalMailGuildBattleScoreReward, int32(serverproto.MailType_MailType_GuildBattle_Score),
					reward.RewardList, []int32{data.RewardType}, "", "")
			}
		}
		//发送击杀奖励
		for _, data := range msg.KillerMvp {
			reward, ok := model.GuildBattleKillMvpReward[data.RewardType]
			if ok {
				role.(model2.RoleLogicOuter).AddMail1(model.GlobalMailGuildBattleKillerReward, int32(serverproto.MailType_MailType_GuildBattle_Killer),
					reward.RewardList, []int32{data.RewardType}, "", "")
			}
		}
		//todo wangzhaocan 设置MVP领奖标记
		if msg.CurMvpRound != 0 {
			role.(*model2.Role).GetRoleGuild().SetGuildBattleMvpRound(msg.CurMvpRound)
		}
	})

	//赛季结束，发送MVP奖励
	serverproto.Handle_GAME_SSGuildBattleSendMvpRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGuildBattleSendMvpRewardReq)

		util.InfoF("uid=%v receive SSGuildBattleSendMvpRewardReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSGuildBattleSendMvpRewardAck{}
		//发送积分奖励
		uidList := map[uint64]int32{}
		for _, data := range msg.ScoreMvp {
			newCliId := &model.ClientID{
				SessID: data.Uid,
			}
			role := model2.RoleMag.GetRole(*newCliId)
			if role == nil {
				continue
			}
			reward, ok := model.GuildBattleScoreMvpReward[data.RewardType]
			if ok {
				role.(model2.RoleLogicOuter).AddMail1(model.GlobalMailGuildBattleScoreReward, int32(serverproto.MailType_MailType_GuildBattle_Score),
					reward.RewardList, []int32{data.RewardType}, "", "")

				ackMsg.ScoreMvp = append(ackMsg.ScoreMvp, &serverproto.MvpRewardInfo{
					Uid:         data.Uid,
					BattleIndex: data.BattleIndex,
				})
			}
			uidList[data.Uid] = 1
		}
		//发送击杀奖励
		for _, data := range msg.KillerMvp {
			newCliId := &model.ClientID{
				SessID: data.Uid,
			}
			role := model2.RoleMag.GetRole(*newCliId)
			if role == nil {
				continue
			}
			reward, ok := model.GuildBattleKillMvpReward[data.RewardType]
			if ok {
				role.(model2.RoleLogicOuter).AddMail1(model.GlobalMailGuildBattleKillerReward, int32(serverproto.MailType_MailType_GuildBattle_Killer),
					reward.RewardList, []int32{data.RewardType}, "", "")
				ackMsg.KillerMvp = append(ackMsg.KillerMvp, &serverproto.MvpRewardInfo{
					Uid:         data.Uid,
					BattleIndex: data.BattleIndex,
				})
			}
			uidList[data.Uid] = 1
		}

		if len(ackMsg.KillerMvp) > 0 || len(ackMsg.ScoreMvp) > 0 {
			model2.SendGuild(ackMsg)
		}
	})

	//魔王信息请求
	serverproto.Handle_GAME_CSGuildDemonInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildDemonInfoReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildDemonInfoReq msg=%v", role.GetUUid(), msg)
		msg.Uid = role.GetUUid()
		msg.GuildId = role.(model2.RoleLogicOuter).GetRoleGuildId()

		model2.SendGuild(msg)
	})

	//战斗结果通知
	serverproto.Handle_GAME_CSGuildDemonFightReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildDemonFightReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildDemonFightReq msg=%v", role.GetUUid(), msg)
		/*
			ackMsg := &serverproto.SCGuildDemonFightAck{
				Error: int32(serverproto.ErrorCode_ERROR_FAIL),
			}
			role.ReplayGate(ackMsg, true)
			return
		*/

		//check中直接扣除次数
		bRet := role.(*model2.Role).GetRoleGuild().CheckDemonChallenge()
		if bRet != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCGuildDemonFightAck{
				Error: int32(bRet),
			}
			role.ReplayGate(ackMsg, true)
			return
		}
		//返回包返回到game再重置次数
		reqMsg := &serverproto.SSGuildDemonFightReq{
			DemonId: msg.DemonId,
			Damage:  msg.Damage,
			GuildId: role.(model2.RoleLogicOuter).GetRoleGuildId(),
			Uid:     role.GetUUid(),
		}
		model2.SendGuild(reqMsg)
	})

	//魔王公会排名
	serverproto.Handle_GAME_CSGuildDemonGuildRankReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildDemonGuildRankReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildDemonGuildRankReq msg=%v", role.GetUUid(), msg)

		msg.GuildId = role.(model2.RoleLogicOuter).GetRoleGuildId()
		msg.Uid = role.GetUUid()
		//返回包返回到game再重置次数
		model2.SendGuild(msg)
	})

	//魔王公会排名
	serverproto.Handle_GAME_CSGuildDemonMVPRankReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildDemonMVPRankReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildDemonMVPRankReq msg=%v", role.GetUUid(), msg)

		msg.GuildId = role.(model2.RoleLogicOuter).GetRoleGuildId()
		msg.Uid = role.GetUUid()
		//返回包返回到game再重置次数
		model2.SendGuild(msg)
	})

	//购买战斗次数
	serverproto.Handle_GAME_CSGuildDemonBuyFightCountReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSGuildDemonBuyFightCountReq)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive CSGuildDemonBuyFightCountReq msg=%v", role.GetUUid(), msg)

		role.(model2.RoleLogicOuter).GuildDemonBuyFightCount(msg.FightCount)
	})
	//===========================     魔王，公会服务器返回     =================================
	//魔王公会排名
	serverproto.Handle_GAME_SCGuildDemonInfoAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildDemonInfoAck)

		newCliId := &model.ClientID{
			SessID: msg.ReqUid,
		}
		role := model2.RoleMag.GetRole(*newCliId)
		if role == nil {
			return
		}

		util.InfoF("uid=%v receive SCGuildDemonInfoAck msg=%v", role.GetUUid(), msg)

		role.(*model2.Role).GetRoleGuild().GetGuildDemonInfo(msg)
		//返回包返回到game再重置次数
		role.ReplayGate(msg, true)
	})

	//魔王公会排名
	serverproto.Handle_GAME_SSGuildDemonFightAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGuildDemonFightAck)

		newCliId := &model.ClientID{
			SessID: msg.ReqUid,
		}
		role := model2.RoleMag.GetRole(*newCliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SSGuildDemonFightAck msg=%v", role.GetUUid(), msg)

		ackMsg := &serverproto.SCGuildDemonFightAck{
			Error:       msg.Error,
			DemonId:     msg.DemonId,
			FightCount:  msg.FightCount,
			TotalDamage: msg.TotalDamage,
		}
		//返回包返回到game再重置次数
		role.(*model2.Role).GetRoleGuild().OnGuildDemonFight(msg.RefreshTime, msg.FreeFightCount, ackMsg)
		role.ReplayGate(ackMsg, true)

		if msg.RewardLevel > 0 {
			role.(*model2.Role).GetRoleGuild().SendGuildDemonBroadCast(msg.DemonId, msg.GuildName, msg.RewardLevel)
		}
	})

	//魔王公会排名
	serverproto.Handle_GAME_SCGuildDemonGuildRankAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildDemonGuildRankAck)
		newCliId := &model.ClientID{
			SessID: msg.Uid,
		}
		role := model2.RoleMag.GetRole(*newCliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildDemonGuildRankAck msg=%v", role.GetUUid(), msg)

		//返回包返回到game再重置次数
		role.ReplayGate(msg, true)
	})

	//魔王公会排名
	serverproto.Handle_GAME_SCGuildDemonMVPRankAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCGuildDemonMVPRankAck)
		newCliId := &model.ClientID{
			SessID: msg.Uid,
		}
		role := model2.RoleMag.GetRole(*newCliId)
		if role == nil {
			return
		}
		util.InfoF("uid=%v receive SCGuildDemonMVPRankAck msg=%v", role.GetUUid(), msg)
		role.ReplayGate(msg, true)
	})
	//魔王公会上线奖励
	serverproto.Handle_GAME_SSGuildDemonOnlineGetRewardNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGuildDemonOnlineGetRewardNtf)
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}
		//		return
		util.InfoF("uid=%v receive SSGuildDemonOnlineGetRewardNtf msg=%v", role.GetUUid(), msg)
		role.(*model2.Role).GetRoleGuild().OnlineAddGuildDemonReward(msg)
	})

	//邮件
	serverproto.Handle_GAME_SSGuildDemonRewardNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGuildDemonRewardNtf)
		util.InfoF("receive SSGuildDemonRewardNtf msg=%v", msg)

		demonData := model.GetDemonDataByConfigId(msg.DemonId)
		if demonData == nil || len(demonData.BaseReward) <= 0 {
			util.ErrorF("get demon config not found : demon:%v", msg.DemonId)
			return
		}
		var rewardData []*serverproto.KeyValueType
		for _, data := range demonData.RewardStage {
			if data.StageMin <= msg.TotalDamage && (msg.TotalDamage <= data.StageMax || data.Level >= int32(len(demonData.RewardStage))) {
				rewardData = data.Reward
				break
			}
		}
		if len(rewardData) <= 0 {
			util.InfoF("reward list empty: demon:%v, damage:%v", msg.DemonId, msg.TotalDamage)
			return
		}

		for _, uid := range msg.UidList {
			role := model2.RoleMag.GetRoleFromUUid(uid)
			if role == nil {
				role = model2.RoleMag.GetRoleFromOffline(uid)
			}
			if role != nil {
				role.(*model2.Role).GetRoleGuild().AddGuildDemonReward(rewardData, msg)
			}
		}
	})
}