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

package msg

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

func init() {
	//发送聊天信息
	//消息类型1私人聊天，2世界频道聊天
	serverproto.Handle_GAME_CSChatMessageReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSChatMessageReq)

		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		util.InfoF("uid=%v nickname=%v receive CSChatMessageReq msg=%v", role.GetOpenId(), role.GetNickName(), string(msg.Message.Message))

		role.(model2.RoleLogicOuter).CheckChatInvalid(msg.TargetId, msg.Type, msg)
	})

	//私聊消息发送失败，存到离线信息中，并告诉客户端当前玩家离线
	serverproto.Handle_GAME_SSChatMessageAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSChatMessageAck)
		util.DebugF("receive SSChatMessageAck msg from other player msg=%v", msg)

		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}

		ackMsg := &serverproto.SCChatMessageAck{
			Error:    int32(serverproto.ErrorCode_ERROR_OK),
			Type:     msg.Type,
			TargetId: msg.TargetId,
			Message:  msg.Message,
		}
		//发送在线聊天信息成功，回复自己
		if msg.Error == int32(serverproto.ErrorCode_ERROR_OK) {
			//send to db-mysql
			role.(*model2.Role).GetRoleChat().SendDB2Mysql(role.GetUUid(), msg.TargetId, msg.Type, msg.Message)

			role.ReplayGate(ackMsg, true)
			return
		}

		//离线消息存储(会有一次性获取不全离线消息的情况，正好在保存离线消息时，另外一个玩家上线并获取了
		// 之前的离线数据，需要下次再上线时才能获取该次离线数据)
		//需要做及时保存，否则玩家上线时将不会获取到离线消息
		ssMsg := &serverproto.SSChatMessageSaveReq{
			TargetId: msg.TargetId,
			FromPlayer: &serverproto.ChatPlayerBriefInfo{
				Uid:         role.GetUUid(),
				NickName:    role.GetNickName(),
				ImgId:       role.(*model2.Role).GetImageId(),
				ConfigId:    role.(*model2.Role).GetRoleHero().GetMainHero().ConfigId,
				Level:       role.(*model2.Role).GetRoleLevel(),
				HeadFrameId: role.(*model2.Role).GetRoleBase().RoleData().HeadFrameId,
				Gender:      role.(*model2.Role).GetRoleBase().GetRoleSex(),
				VipLevel:    role.(*model2.Role).GetRoleVipLevel(),
				HeadId:      role.(*model2.Role).GetHeadId(),
			},
			OfflineMsg: msg.Message,
		}
		role.(*model2.Role).SendDb(ssMsg)

		//send to db-mysql
		role.(*model2.Role).GetRoleChat().SendDB2Mysql(role.GetUUid(), msg.TargetId, msg.Type, msg.Message)

		//ackMsg.Error = int32(serverproto.ErrorCode_ERROR_CHAT_WORLD_TARGET_OFFLINE)
		if ackMsg.Type == int32(serverproto.ChatMessageType_CMT_PERSONAL) {
			ackMsg.Error = msg.Error
		} else {
			ackMsg.Error = int32(serverproto.ErrorCode_ERROR_OK)
		}

		role.ReplayGate(ackMsg, true)
	})

	//来自social消息(来自其他game的聊天消息)
	serverproto.Handle_GAME_SSChatMessageNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSChatMessageNtf)
		util.DebugF("receive SSChatMessageNtf msg from other player msg=%v", msg)

		chatNtf := &serverproto.SCChatMessageNtf{}
		chatNtf.MsgList = append(chatNtf.MsgList, &serverproto.MessageContentInfo{
			Type:     msg.Type,
			FromId:   msg.FromId,
			Message:  msg.Message,
			TargetId: msg.TargetId,
		})

		if msg.Type == int32(serverproto.ChatMessageType_CMT_PERSONAL) ||
			msg.Type == int32(serverproto.ChatMessageType_CMT_GUILD) {
			targetRole := model2.RoleMag.GetRoleFromUUid(msg.TargetId)
			if targetRole == nil {
				return
			}

			if !targetRole.(*model2.Role).GetRoleSocial().IsInBlackList(msg.FromId.Uid) {
				targetRole.(model2.RoleOuter).ReplayGate(chatNtf, true)
			}
		} else if msg.Type == int32(serverproto.ChatMessageType_CMT_WORLD) {
			model2.AddWorldMsg(msg.Type, msg.FromId, msg.Message, nil)
			//发送给当前服务器的所有玩家
			model2.RoleMag.SendMsg2OnlinePlayer(chatNtf, msg.FromId.Uid)
		}
	})

	//私聊玩家在线状态获取
	serverproto.Handle_GAME_CSChatPlayerStateReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSChatPlayerStateReq)
		util.DebugF("receive CSChatPlayerStateReq msg msg=%v", msg)

		//发送给social获取在线状态
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		if len(msg.TargetIdList) <= 0 {
			return
		} else if msg.TargetIdList[0] == role.GetUUid() {
			util.InfoF("uid=%v receive CSChatPlayerStateReq is self invalid", role.GetUUid())
			return
		}

		role.(*model2.Role).SendSocial(msg)
	})

	//来自social，获取玩家在线状态消息回复
	serverproto.Handle_GAME_SCChatPlayerStateAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCChatPlayerStateAck)
		util.DebugF("receive SCChatPlayerStateAck msg=%v", msg)

		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}

		role.ReplayGate(msg, true)
	})

	//获取离线消息
	serverproto.Handle_GAME_CSChatOfflineMsgReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSChatOfflineMsgReq)
		util.DebugF("uid=%v receive CSChatOfflineMsgReq msg=%v", cliId.SessID, msg)

		//发送给social获取在线状态
		role := model2.RoleMag.GetRoleOrKick(cliId, ev)
		if role == nil {
			return
		}

		role.(model2.RoleLogicOuter).GetOfflineMsg(msg.TargetId)
	})
	//获取离线消息回复(db)
	serverproto.Handle_GAME_SCChatOfflineMsgAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SCChatOfflineMsgAck)
		util.DebugF("receive SCChatOfflineMsgAck msg:=%v", msg)

		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}

		role.ReplayGate(msg, true)
	})

	//获取离线信息玩家列表回复(db)
	serverproto.Handle_GAME_SSChatOfflinePlayerAck = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSChatOfflinePlayerAck)
		util.DebugF("receive SSChatOfflinePlayerAck msg:=%v", msg)

		role := model2.RoleMag.GetRole(cliId)
		if role == nil {
			return
		}

		if msg.RoleOfflineMsgList != nil {
			role.(*model2.Role).GetRoleChat().AddOfflineMsg(msg.RoleOfflineMsgList.OfflineMsgPlayerList)
		}

		ntfMsg := &serverproto.SCChatOfflinePlayerNtf{
			OfflinePlayerList: msg.RoleOfflineMsgList,
		}
		role.ReplayGate(ntfMsg, true)
	})
}