RoServer/RO_Server_Trunk-branch_bt/roserver/game/model/role_send.go

package model

import (
	"rocommon/rpc"
	"rocommon/util"
	"roserver/baseserver/model"
	"roserver/serverproto"
	"time"
)

/////////////////////////////////////////////发送数据
//透传给gate服务器，然后在发送给客户端
//transmit是否透传，gate是否处理该消息，true表示透传,false表示gate需要做处理
//直接回复可以使用ServiceReplay，后续通过其他服务器处理的话需要调用接口ReplayGate
//model.ServiceReplay(ev, ack)

var testNowTime time.Time = util.GetCurrentTimeNow()
var SCSyncPlayersNtfCount int32 = 0
var SCPlayerLeaveNtfCount int32 = 0
var SCPlayerEnterNtfCount int32 = 0

func (this *Role) ReplayGate(msg interface{}, transmit bool) int {
	//当前玩家不在线
	gateSess := model.GetServiceNode(this.cliID.ServiceID)
	if gateSess == nil {
		util.ErrorF("ReplayGate gate not not found cliId=%v", this.cliID)
		return 0
	}

	data, info, err := rpc.EncodeMessage(msg)
	if err != nil {
		util.ErrorF("ReplayGate gate EncodeMessage err=%v,cliId=%v", err, this.cliID)
		return 0
	}

	//未成功发送登录结构信息之前，发送其他结构消息
	if this.GetState() != ROLE_STATE_ONLINE && info.ID > 1020 {
		if this.tmpState {
			util.ErrorF("uid=%v ReplayGate before online cliId=%v msgid=%v\n", this.GetUUid(), this.cliID, info.ID)
			return 0
		}
	}

	var ackSeqId uint32 = 0
	var confirmId = uint32(info.ConfirmMsgId)
	if info.ConfirmMsgId > 0 {
		confirmLen := len(this.reqAckConfirmList[confirmId])
		if confirmLen > 0 {
			ackSeqId = this.reqAckConfirmList[confirmId][confirmLen-1]
			this.reqAckConfirmList[confirmId] = this.reqAckConfirmList[confirmId][:confirmLen-1]
		}
	}
	if transmit {
		//透传给gate服务器，然后再发送给客户端
		gateSess.Send(&serverproto.ServiceTransmitAck{
			MsgId:    uint32(info.ID),
			MsgData:  data,
			ClientId: this.cliID.SessID,
			SeqId:    ackSeqId,
			//KvTime:   util.GetTimeMilliseconds(),
		})
	} else {
		//发给gate服务器做做处理操作
		gateSess.Send(msg)
	}

	//switch msg.(type) {
	//case *serverproto.SCSyncPlayersNtf:
	//	SCSyncPlayersNtfCount++
	//case *serverproto.SCPlayerLeaveNtf:
	//	SCPlayerLeaveNtfCount++
	//case *serverproto.SCPlayerEnterNtf:
	//	SCPlayerEnterNtfCount++
	//}
	////log.Println("replay gate...", msg)
	//if time.Since(testNowTime) > time.Second {
	//	testNowTime = util.GetCurrentTimeNow()
	//	//log.Println("replay gate...[sync,leave,enter]",SCSyncPlayersNtfCount, SCPlayerLeaveNtfCount, SCPlayerEnterNtfCount)
	//	SCSyncPlayersNtfCount = 0
	//	SCPlayerLeaveNtfCount = 0
	//	SCPlayerEnterNtfCount = 0
	//}

	return len(data)
}

func ReplayGateList(msg interface{}, clientIdList []uint64, serviceID string, transmit bool) int {
	//当前玩家不在线
	gateSess := model.GetServiceNode(serviceID)
	if gateSess == nil {
		util.ErrorF("ReplayGate gate not not found serviceID=%v msg=%v", serviceID, msg)
		return 0
	}

	data, info, err := rpc.EncodeMessage(msg)
	if err != nil {
		util.ErrorF("ReplayGate gate EncodeMessage err=%v", err)
		return 0
	}

	if transmit {
		//透传给gate服务器，然后再发送给客户端
		sendMsg := &serverproto.ServiceTransmitAck{
			MsgId:   uint32(info.ID),
			MsgData: data,
			//KvTime:   util.GetTimeMilliseconds(),
		}
		sendMsg.ClientIdList = append(sendMsg.ClientIdList, clientIdList...)
		//sendMsg.ClientIdList = clientIdList
		gateSess.Send(sendMsg)
	} else {
		//发给gate服务器做做处理操作
		//gateSess.Send(msg)
	}

	//switch msg.(type) {
	//case *serverproto.SCSyncPlayersNtf:
	//	SCSyncPlayersNtfCount++
	//case *serverproto.SCPlayerLeaveNtf:
	//	SCPlayerLeaveNtfCount++
	//case *serverproto.SCPlayerEnterNtf:
	//	SCPlayerEnterNtfCount++
	//}
	////log.Println("replay gate...", msg)
	//if time.Since(testNowTime) > time.Second {
	//	testNowTime = util.GetCurrentTimeNow()
	//	//log.Println("replay gate...[sync,leave,enter]",SCSyncPlayersNtfCount, SCPlayerLeaveNtfCount, SCPlayerEnterNtfCount)
	//	SCSyncPlayersNtfCount = 0
	//	SCPlayerLeaveNtfCount = 0
	//	SCPlayerEnterNtfCount = 0
	//}

	return len(data)
}

// 发送给db服务器
func (this *Role) SendDb(msg interface{}) bool {
	data, meta, err := rpc.EncodeMessage(msg)
	if err != nil {
		util.ErrorF("EncodeMessage err=%v msg=%v", err, msg)
		return false
	}

	tmpServiceNode, tmpDBSess := model.GetServiceNodeAndSession(this.DBNode(), model.SERVICE_NODE_TYPE_DB_STR, 0)
	if tmpServiceNode == "" {
		util.ErrorF("SendDb session not exist dbNode=%v", this.DBNode())
		return false
	}
	this.dbNode = tmpServiceNode

	//如果玩家信息存在，ClientId中存放的是玩家ID，否则存放的是玩家的gate sessionId
	if this.uuid != 0 {
		tmpDBSess.Send(&serverproto.ServiceTransmitAck{
			MsgId:    uint32(meta.ID),
			MsgData:  data,
			ClientId: this.uuid, //对应的玩家 gate uuid uuidRoleList[key]
		})
	} else {
		tmpDBSess.Send(&serverproto.ServiceTransmitAck{
			MsgId:    uint32(meta.ID),
			MsgData:  data,
			ClientId: this.CliID().SessID, //对应的玩家 gate channelId channelRoleList[key]
		})
	}
	return true
}

func (this *Role) SendAllSocial(msg interface{}) {
	data, meta, err := rpc.EncodeMessage(msg)
	if err != nil {
		util.ErrorF("SendSocial EncodeMessage err=%v,msg=%v", err, msg)
		return
	}
	sendMsg := &serverproto.ServiceTransmitAck{
		MsgId:   uint32(meta.ID),
		MsgData: data,
	}
	//如果玩家信息存在，ClientId中存放的是玩家ID，否则存放的是玩家的gate sessionId
	if this.uuid != 0 {
		sendMsg.ClientId = this.uuid //对应的玩家 gate uuid uuidRoleList[key]
	} else {
		sendMsg.ClientId = this.CliID().SessID //对应的玩家 gate channelId channelRoleList[key]
	}

	serviceList := model.GetAllServiceNodeByName(model.SERVICE_NODE_TYPE_SOCIAL_STR)
	for _, node := range serviceList {
		socialSess := model.GetServiceNode(node)
		if socialSess != nil {
			socialSess.Send(sendMsg)
		}
	}
}

// 发送给social服务器
func (this *Role) SendSocial(msg interface{}) bool {
	//todo...
	// 暂时做成单点，后续做扩展
	// 玩家上线时需要发送给social，标记当前玩家上线并通知好友

	tmpServiceNode, tmpSocialSess := model.GetServiceNodeAndSession(this.SocialNode(), model.SERVICE_NODE_TYPE_SOCIAL_STR, 0)
	if tmpServiceNode == "" {
		util.ErrorF("SendSocial social session not exist socialnode=%v", this.SocialNode())
		return false
	}
	this.socialNode = tmpServiceNode

	data, meta, err := rpc.EncodeMessage(msg)
	if err != nil {
		util.ErrorF("SendSocial EncodeMessage err=%v,msg=%v", err, msg)
		return false
	}
	//AOI地图处理
	targetServiceNodeSID := ""
	if this.GetRoleCross() != nil {
		targetServiceNodeSID = this.GetRoleCross().curMapSID
	}
	//如果玩家信息存在，ClientId中存放的是玩家ID，否则存放的是玩家的gate sessionId
	if this.uuid != 0 {
		tmpSocialSess.Send(&serverproto.ServiceTransmitAck{
			MsgId:             uint32(meta.ID),
			MsgData:           data,
			ClientId:          this.uuid, //对应的玩家 gate uuid uuidRoleList[key]
			TargetServiceNode: targetServiceNodeSID,
		})
	} else {
		tmpSocialSess.Send(&serverproto.ServiceTransmitAck{
			MsgId:             uint32(meta.ID),
			MsgData:           data,
			ClientId:          this.CliID().SessID, //对应的玩家 gate channelId channelRoleList[key]
			TargetServiceNode: targetServiceNodeSID,
		})
	}
	return true
}

// 发送给social服务器
func (this *Role) SendSocialWithSID(msg interface{}, targetNodeSID string) bool {
	//todo...
	// 暂时做成单点，后续做扩展
	// 玩家上线时需要发送给social，标记当前玩家上线并通知好友

	tmpServiceNode, tmpSocialSess := model.GetServiceNodeAndSession(this.SocialNode(), model.SERVICE_NODE_TYPE_SOCIAL_STR, 0)
	if tmpServiceNode == "" {
		util.ErrorF("SendSocial social session not exist socialnode=%v", this.SocialNode())
		return false
	}
	this.socialNode = tmpServiceNode

	data, meta, err := rpc.EncodeMessage(msg)
	if err != nil {
		util.ErrorF("SendSocial EncodeMessage err=%v,msg=%v", err, msg)
		return false
	}
	//如果玩家信息存在，ClientId中存放的是玩家ID，否则存放的是玩家的gate sessionId
	if this.uuid != 0 {
		tmpSocialSess.Send(&serverproto.ServiceTransmitAck{
			MsgId:             uint32(meta.ID),
			MsgData:           data,
			ClientId:          this.uuid, //对应的玩家 gate uuid uuidRoleList[key]
			TargetServiceNode: targetNodeSID,
			IsMaster:          true,
		})
	} else {
		tmpSocialSess.Send(&serverproto.ServiceTransmitAck{
			MsgId:             uint32(meta.ID),
			MsgData:           data,
			ClientId:          this.CliID().SessID, //对应的玩家 gate channelId channelRoleList[key]
			TargetServiceNode: targetNodeSID,
			IsMaster:          true,
		})
	}
	return true
}

//send master and ghost
//func (this *Role) SendAoi(msg interface{}) bool {
//	tmpServiceNode, tmpSocialSess := model.GetServiceNodeAndSession(this.aoiNode, model.SERVICE_NODE_TYPE_AOI_STR, this.cliID.SessID>>32)
//	if tmpServiceNode == "" {
//		util.ErrorF("SendAoi session not exist servicenode=%v", this.aoiNode)
//		return false
//	}
//	this.aoiNode = tmpServiceNode
//
//	//return this.sendService(msg, this.aoiNode)
//	data, meta, err := rpcc.EncodeMessage(msg)
//	if err != nil {
//		util.ErrorF("sendService EncodeMessage err=%v,msg=%v", err, msg)
//		return false
//	}
//
//	sendMasterMsg := &serverproto.ServiceTransmitAck{
//		MsgId:    uint32(meta.ID),
//		MsgData:  data,
//		ClientId: this.cliID.SessID, //对应的玩家 gate cliId SessionId
//		IsMaster: true,
//	}
//	tmpSocialSess.Send(sendMasterMsg)
//
//	serviceList := model.GetAllServiceNodeByName(model.SERVICE_NODE_TYPE_AOI_STR)
//	if len(serviceList) > 1 {
//		sendGhostMsg := &serverproto.ServiceTransmitAck{
//			MsgId:    uint32(meta.ID),
//			MsgData:  data,
//			ClientId: this.cliID.SessID, //对应的玩家 gate cliId SessionId
//			IsMaster: false,
//		}
//		for _, node := range serviceList {
//			aoiSess := model.GetServiceNode(node)
//			if aoiSess != nil && node != this.aoiNode {
//				aoiSess.Send(sendGhostMsg)
//			}
//		}
//	}
//
//	return true
//}

//发送给其他非master aoi节点
//func (this *Role) SendGhostAoi(msg interface{}) bool {
//	data, meta, err := rpcc.EncodeMessage(msg)
//	if err != nil {
//		util.ErrorF("sendService EncodeMessage err=%v,msg=%v", err, msg)
//		return false
//	}
//
//	sendMsg := &serverproto.ServiceTransmitAck{
//		MsgId:    uint32(meta.ID),
//		MsgData:  data,
//		ClientId: this.cliID.SessID, //对应的玩家 gate cliId SessionId
//		IsMaster: false,
//	}
//	serviceList := model.GetAllServiceNodeByName(model.SERVICE_NODE_TYPE_AOI_STR)
//	if len(serviceList) > 0 {
//		for _, node := range serviceList {
//			aoiSess := model.GetServiceNode(node)
//			if aoiSess != nil && node != this.aoiNode {
//				aoiSess.Send(sendMsg)
//			}
//		}
//	}
//	return true
//}

// battle boss
func (this *Role) SendBattleBoss(msg interface{}) bool {
	if this.bossNode == "" {
		this.bossNode = model.SelectServiceNode(model.SERVICE_NODE_TYPE_BOSS_STR, 0)
	}
	if this.bossNode == "" {
		util.ErrorF("SendBoss Boss Server node not exist msg=%v", msg)
		return false
	}

	return this.sendService(msg, this.bossNode)
}

// rank
func (this *Role) SendRank(msg interface{}) bool {
	if this.RankNode() == "" {
		this.rankNode = model.SelectServiceNode(model.SERVICE_NODE_TYPE_RANK_STR, 0)
	}
	if this.rankNode == "" {
		util.InfoF("SendRank Rank Server node not exist msg=%v", msg)
		return false
	}

	return this.sendService(msg, this.rankNode)
}

// guild
func (this *Role) SendGuild(msg interface{}) bool {
	if this.GuildNode() == "" {
		this.guildNode = model.SelectServiceNode(model.SERVICE_NODE_TYPE_GUILD_STR, 0)
	}
	if this.guildNode == "" {
		util.ErrorF("SendGuild Guild Server node not exist msg=%v", msg)
		return false
	}

	return this.sendService(msg, this.guildNode)
}

func (this *Role) sendService(msg interface{}, serviceNode string) bool {
	data, meta, err := rpc.EncodeMessage(msg)
	if err != nil {
		util.ErrorF("sendService EncodeMessage err=%v,msg=%v", err, msg)
		return false
	}

	serviceSess := model.GetServiceNode(serviceNode)
	if serviceSess == nil {
		util.ErrorF("sendService session not exist servicenode=%v", serviceNode)
	} else {
		//如果玩家信息存在，ClientId中存放的是玩家ID，否则存放的是玩家的gate sessionId
		if this.uuid != 0 {
			serviceSess.Send(&serverproto.ServiceTransmitAck{
				MsgId:   uint32(meta.ID),
				MsgData: data,
				//todo...
				// 对应的玩家 gate channelId channelRoleList[key]
				// 后续和gate直接通信时使用，如果断线重连需要重新绑定
				ClientId: this.uuid, //对应的玩家 gate uuid uuidRoleList[key]
			})
		}
	}

	return true
}

func SendDb(msg interface{}) bool {
	data, meta, err := rpc.EncodeMessage(msg)
	if err != nil {
		util.ErrorF("EncodeMessage err=%v,msg=%v", err, msg)
		return false
	}

	dbNode, dbSess := model.GetServiceNodeAndSession("", model.SERVICE_NODE_TYPE_DB_STR, 0)
	if dbSess == nil {
		util.ErrorF("db session not exist dbNode=%v", dbNode)
		return false
	} else {
		dbSess.Send(&serverproto.ServiceTransmitAck{
			MsgId:   uint32(meta.ID),
			MsgData: data,
		})
	}

	return true
}
func SendSocial(msg interface{}) bool {
	data, meta, err := rpc.EncodeMessage(msg)
	if err != nil {
		util.ErrorF("EncodeMessage err=%v,msg=%v", err, msg)
		return false
	}

	_, socialSess := model.GetServiceNodeAndSession("", model.SERVICE_NODE_TYPE_SOCIAL_STR, 0)
	if socialSess == nil {
		util.ErrorF("social session not exist  msgid=%v", meta.ID)
		return false
	} else {
		socialSess.Send(&serverproto.ServiceTransmitAck{
			MsgId:   uint32(meta.ID),
			MsgData: data,
		})
	}

	return true
}

func SendGuild(msg interface{}) bool {
	data, meta, err := rpc.EncodeMessage(msg)
	if err != nil {
		util.ErrorF("EncodeMessage err=%v,msg=%v", err, msg)
		return false
	}

	guildNode, guildSess := model.GetServiceNodeAndSession("", model.SERVICE_NODE_TYPE_GUILD_STR, 0)
	if guildSess == nil {
		util.ErrorF("db session not exist dbNode=%v", guildNode)
		return false
	} else {
		guildSess.Send(&serverproto.ServiceTransmitAck{
			MsgId:   uint32(meta.ID),
			MsgData: data,
		})
	}

	return true
}

func SendRankService(msg interface{}) {
	data, meta, err := rpc.EncodeMessage(msg)
	if err != nil {
		util.ErrorF("SendRankService EncodeMessage err=%v,msg=%v", err, msg)
		return
	}

	rankNode, serviceSess := model.GetServiceNodeAndSession("", model.SERVICE_NODE_TYPE_RANK_STR, 0)
	if serviceSess == nil {
		util.ErrorF("sendService session not exist rankNode=%v", rankNode)
	} else {
		//如果玩家信息存在，ClientId中存放的是玩家ID，否则存放的是玩家的gate sessionId
		serviceSess.Send(&serverproto.ServiceTransmitAck{
			MsgId:   uint32(meta.ID),
			MsgData: data,
			//todo...
			// 对应的玩家 gate channelId channelRoleList[key]
			// 后续和gate直接通信时使用，如果断线重连需要重新绑定
			ClientId: 0, //对应的玩家 gate uuid uuidRoleList[key]
		})
	}
}