mirror of
https://github.com/FlourishingWorld/hk4e.git
synced 2026-02-04 17:02:26 +08:00
507 lines
18 KiB
Go
507 lines
18 KiB
Go
package game
|
|
|
|
import (
|
|
"regexp"
|
|
"time"
|
|
"unicode/utf8"
|
|
|
|
"hk4e/common/constant"
|
|
"hk4e/common/mq"
|
|
"hk4e/gs/model"
|
|
"hk4e/pkg/logger"
|
|
"hk4e/pkg/object"
|
|
"hk4e/protocol/cmd"
|
|
"hk4e/protocol/proto"
|
|
|
|
pb "google.golang.org/protobuf/proto"
|
|
)
|
|
|
|
func (g *Game) GetPlayerSocialDetailReq(player *model.Player, payloadMsg pb.Message) {
|
|
req := payloadMsg.(*proto.GetPlayerSocialDetailReq)
|
|
targetUid := req.Uid
|
|
|
|
targetPlayer, _, _ := USER_MANAGER.LoadGlobalPlayer(targetUid)
|
|
if targetPlayer == nil {
|
|
g.SendError(cmd.GetPlayerSocialDetailRsp, player, &proto.GetPlayerSocialDetailRsp{}, proto.Retcode_RET_PLAYER_NOT_EXIST)
|
|
return
|
|
}
|
|
_, exist := player.FriendList[targetPlayer.PlayerID]
|
|
socialDetail := &proto.SocialDetail{
|
|
Uid: targetPlayer.PlayerID,
|
|
ProfilePicture: &proto.ProfilePicture{AvatarId: targetPlayer.HeadImage},
|
|
Nickname: targetPlayer.NickName,
|
|
Signature: targetPlayer.Signature,
|
|
Level: targetPlayer.PropertiesMap[constant.PLAYER_PROP_PLAYER_LEVEL],
|
|
Birthday: &proto.Birthday{Month: uint32(targetPlayer.Birthday[0]), Day: uint32(targetPlayer.Birthday[1])},
|
|
WorldLevel: targetPlayer.PropertiesMap[constant.PLAYER_PROP_PLAYER_WORLD_LEVEL],
|
|
NameCardId: targetPlayer.NameCard,
|
|
IsShowAvatar: false,
|
|
FinishAchievementNum: 0,
|
|
IsFriend: exist,
|
|
}
|
|
getPlayerSocialDetailRsp := &proto.GetPlayerSocialDetailRsp{
|
|
DetailData: socialDetail,
|
|
}
|
|
g.SendMsg(cmd.GetPlayerSocialDetailRsp, player.PlayerID, player.ClientSeq, getPlayerSocialDetailRsp)
|
|
}
|
|
|
|
func (g *Game) SetPlayerBirthdayReq(player *model.Player, payloadMsg pb.Message) {
|
|
req := payloadMsg.(*proto.SetPlayerBirthdayReq)
|
|
if player.Birthday[0] != 0 || player.Birthday[1] != 0 {
|
|
g.SendError(cmd.SetPlayerBirthdayRsp, player, &proto.SetPlayerBirthdayRsp{})
|
|
return
|
|
}
|
|
birthday := req.Birthday
|
|
player.Birthday[0] = uint8(birthday.Month)
|
|
player.Birthday[1] = uint8(birthday.Day)
|
|
|
|
setPlayerBirthdayRsp := &proto.SetPlayerBirthdayRsp{
|
|
Birthday: req.Birthday,
|
|
}
|
|
g.SendMsg(cmd.SetPlayerBirthdayRsp, player.PlayerID, player.ClientSeq, setPlayerBirthdayRsp)
|
|
}
|
|
|
|
func (g *Game) SetNameCardReq(player *model.Player, payloadMsg pb.Message) {
|
|
req := payloadMsg.(*proto.SetNameCardReq)
|
|
nameCardId := req.NameCardId
|
|
exist := false
|
|
for _, nameCard := range player.NameCardList {
|
|
if nameCard == nameCardId {
|
|
exist = true
|
|
}
|
|
}
|
|
if !exist {
|
|
logger.Error("name card not exist, uid: %v", player.PlayerID)
|
|
return
|
|
}
|
|
player.NameCard = nameCardId
|
|
|
|
setNameCardRsp := &proto.SetNameCardRsp{
|
|
NameCardId: nameCardId,
|
|
}
|
|
g.SendMsg(cmd.SetNameCardRsp, player.PlayerID, player.ClientSeq, setNameCardRsp)
|
|
}
|
|
|
|
func (g *Game) SetPlayerSignatureReq(player *model.Player, payloadMsg pb.Message) {
|
|
req := payloadMsg.(*proto.SetPlayerSignatureReq)
|
|
signature := req.Signature
|
|
|
|
setPlayerSignatureRsp := new(proto.SetPlayerSignatureRsp)
|
|
if !object.IsUtf8String(signature) {
|
|
setPlayerSignatureRsp.Retcode = int32(proto.Retcode_RET_SIGNATURE_ILLEGAL)
|
|
} else if utf8.RuneCountInString(signature) > 50 {
|
|
setPlayerSignatureRsp.Retcode = int32(proto.Retcode_RET_SIGNATURE_ILLEGAL)
|
|
} else {
|
|
player.Signature = signature
|
|
setPlayerSignatureRsp.Signature = player.Signature
|
|
}
|
|
g.SendMsg(cmd.SetPlayerSignatureRsp, player.PlayerID, player.ClientSeq, setPlayerSignatureRsp)
|
|
}
|
|
|
|
func (g *Game) SetPlayerNameReq(player *model.Player, payloadMsg pb.Message) {
|
|
req := payloadMsg.(*proto.SetPlayerNameReq)
|
|
nickName := req.NickName
|
|
|
|
setPlayerNameRsp := new(proto.SetPlayerNameRsp)
|
|
if len(nickName) == 0 {
|
|
setPlayerNameRsp.Retcode = int32(proto.Retcode_RET_NICKNAME_IS_EMPTY)
|
|
} else if !object.IsUtf8String(nickName) {
|
|
setPlayerNameRsp.Retcode = int32(proto.Retcode_RET_NICKNAME_UTF8_ERROR)
|
|
} else if utf8.RuneCountInString(nickName) > 14 {
|
|
setPlayerNameRsp.Retcode = int32(proto.Retcode_RET_NICKNAME_TOO_LONG)
|
|
} else if len(regexp.MustCompile(`\d`).FindAllString(nickName, -1)) > 6 {
|
|
setPlayerNameRsp.Retcode = int32(proto.Retcode_RET_NICKNAME_TOO_MANY_DIGITS)
|
|
} else {
|
|
player.NickName = nickName
|
|
setPlayerNameRsp.NickName = player.NickName
|
|
}
|
|
g.SendMsg(cmd.SetPlayerNameRsp, player.PlayerID, player.ClientSeq, setPlayerNameRsp)
|
|
}
|
|
|
|
func (g *Game) SetPlayerHeadImageReq(player *model.Player, payloadMsg pb.Message) {
|
|
req := payloadMsg.(*proto.SetPlayerHeadImageReq)
|
|
avatarId := req.AvatarId
|
|
dbAvatar := player.GetDbAvatar()
|
|
_, exist := dbAvatar.AvatarMap[avatarId]
|
|
if !exist {
|
|
logger.Error("the head img of the avatar not exist, uid: %v", player.PlayerID)
|
|
return
|
|
}
|
|
player.HeadImage = avatarId
|
|
|
|
setPlayerHeadImageRsp := &proto.SetPlayerHeadImageRsp{
|
|
ProfilePicture: &proto.ProfilePicture{AvatarId: player.HeadImage},
|
|
}
|
|
g.SendMsg(cmd.SetPlayerHeadImageRsp, player.PlayerID, player.ClientSeq, setPlayerHeadImageRsp)
|
|
}
|
|
|
|
func (g *Game) GetAllUnlockNameCardReq(player *model.Player, payloadMsg pb.Message) {
|
|
getAllUnlockNameCardRsp := &proto.GetAllUnlockNameCardRsp{
|
|
NameCardList: player.NameCardList,
|
|
}
|
|
g.SendMsg(cmd.GetAllUnlockNameCardRsp, player.PlayerID, player.ClientSeq, getAllUnlockNameCardRsp)
|
|
}
|
|
|
|
func (g *Game) GetPlayerFriendListReq(player *model.Player, payloadMsg pb.Message) {
|
|
getPlayerFriendListRsp := &proto.GetPlayerFriendListRsp{
|
|
FriendList: make([]*proto.FriendBrief, 0),
|
|
}
|
|
|
|
// 获取包含系统的临时好友列表
|
|
// 用于实现好友列表内的系统且不更改原先的内容
|
|
tempFriendList := COMMAND_MANAGER.GetFriendList(player.FriendList)
|
|
for uid := range tempFriendList {
|
|
|
|
friendPlayer, online, _ := USER_MANAGER.LoadGlobalPlayer(uid)
|
|
if friendPlayer == nil {
|
|
logger.Error("target player is nil, uid: %v", player.PlayerID)
|
|
continue
|
|
}
|
|
var onlineState proto.FriendOnlineState = 0
|
|
if online {
|
|
onlineState = proto.FriendOnlineState_FRIEND_ONLINE
|
|
} else {
|
|
onlineState = proto.FriendOnlineState_FREIEND_DISCONNECT
|
|
}
|
|
friendBrief := &proto.FriendBrief{
|
|
Uid: friendPlayer.PlayerID,
|
|
Nickname: friendPlayer.NickName,
|
|
Level: friendPlayer.PropertiesMap[constant.PLAYER_PROP_PLAYER_LEVEL],
|
|
ProfilePicture: &proto.ProfilePicture{AvatarId: friendPlayer.HeadImage},
|
|
WorldLevel: friendPlayer.PropertiesMap[constant.PLAYER_PROP_PLAYER_WORLD_LEVEL],
|
|
Signature: friendPlayer.Signature,
|
|
OnlineState: onlineState,
|
|
IsMpModeAvailable: true,
|
|
LastActiveTime: player.OfflineTime,
|
|
NameCardId: friendPlayer.NameCard,
|
|
Param: (uint32(time.Now().Unix()) - player.OfflineTime) / 3600 / 24,
|
|
IsGameSource: true,
|
|
PlatformType: proto.PlatformType_PC,
|
|
}
|
|
getPlayerFriendListRsp.FriendList = append(getPlayerFriendListRsp.FriendList, friendBrief)
|
|
}
|
|
g.SendMsg(cmd.GetPlayerFriendListRsp, player.PlayerID, player.ClientSeq, getPlayerFriendListRsp)
|
|
}
|
|
|
|
func (g *Game) GetPlayerAskFriendListReq(player *model.Player, payloadMsg pb.Message) {
|
|
getPlayerAskFriendListRsp := &proto.GetPlayerAskFriendListRsp{
|
|
AskFriendList: make([]*proto.FriendBrief, 0),
|
|
}
|
|
for uid := range player.FriendApplyList {
|
|
friendPlayer, online, _ := USER_MANAGER.LoadGlobalPlayer(uid)
|
|
if friendPlayer == nil {
|
|
logger.Error("target player is nil, uid: %v", player.PlayerID)
|
|
continue
|
|
}
|
|
var onlineState proto.FriendOnlineState
|
|
if online {
|
|
onlineState = proto.FriendOnlineState_FRIEND_ONLINE
|
|
} else {
|
|
onlineState = proto.FriendOnlineState_FREIEND_DISCONNECT
|
|
}
|
|
friendBrief := &proto.FriendBrief{
|
|
Uid: friendPlayer.PlayerID,
|
|
Nickname: friendPlayer.NickName,
|
|
Level: friendPlayer.PropertiesMap[constant.PLAYER_PROP_PLAYER_LEVEL],
|
|
ProfilePicture: &proto.ProfilePicture{AvatarId: friendPlayer.HeadImage},
|
|
WorldLevel: friendPlayer.PropertiesMap[constant.PLAYER_PROP_PLAYER_WORLD_LEVEL],
|
|
Signature: friendPlayer.Signature,
|
|
OnlineState: onlineState,
|
|
IsMpModeAvailable: true,
|
|
LastActiveTime: player.OfflineTime,
|
|
NameCardId: friendPlayer.NameCard,
|
|
Param: (uint32(time.Now().Unix()) - player.OfflineTime) / 3600 / 24,
|
|
IsGameSource: true,
|
|
PlatformType: proto.PlatformType_PC,
|
|
}
|
|
getPlayerAskFriendListRsp.AskFriendList = append(getPlayerAskFriendListRsp.AskFriendList, friendBrief)
|
|
}
|
|
g.SendMsg(cmd.GetPlayerAskFriendListRsp, player.PlayerID, player.ClientSeq, getPlayerAskFriendListRsp)
|
|
}
|
|
|
|
func (g *Game) AskAddFriendReq(player *model.Player, payloadMsg pb.Message) {
|
|
req := payloadMsg.(*proto.AskAddFriendReq)
|
|
targetUid := req.TargetUid
|
|
|
|
askAddFriendRsp := &proto.AskAddFriendRsp{
|
|
TargetUid: targetUid,
|
|
}
|
|
g.SendMsg(cmd.AskAddFriendRsp, player.PlayerID, player.ClientSeq, askAddFriendRsp)
|
|
|
|
targetPlayer := USER_MANAGER.GetOnlineUser(targetUid)
|
|
if targetPlayer == nil {
|
|
// 非本地玩家
|
|
if USER_MANAGER.GetRemoteUserOnlineState(targetUid) {
|
|
// 远程在线玩家
|
|
gsAppId := USER_MANAGER.GetRemoteUserGsAppId(targetUid)
|
|
MESSAGE_QUEUE.SendToGs(gsAppId, &mq.NetMsg{
|
|
MsgType: mq.MsgTypeServer,
|
|
EventId: mq.ServerAddFriendNotify,
|
|
ServerMsg: &mq.ServerMsg{
|
|
AddFriendInfo: &mq.AddFriendInfo{
|
|
OriginInfo: &mq.OriginInfo{
|
|
CmdName: "AskAddFriendReq",
|
|
UserId: player.PlayerID,
|
|
},
|
|
TargetUserId: targetUid,
|
|
ApplyPlayerOnlineInfo: &mq.UserBaseInfo{
|
|
UserId: player.PlayerID,
|
|
Nickname: player.NickName,
|
|
PlayerLevel: player.PropertiesMap[constant.PLAYER_PROP_PLAYER_LEVEL],
|
|
NameCardId: player.NameCard,
|
|
Signature: player.Signature,
|
|
HeadImageId: player.HeadImage,
|
|
WorldLevel: player.PropertiesMap[constant.PLAYER_PROP_PLAYER_WORLD_LEVEL],
|
|
},
|
|
},
|
|
},
|
|
})
|
|
} else {
|
|
// 全服离线玩家
|
|
targetPlayer := USER_MANAGER.LoadTempOfflineUser(targetUid, true)
|
|
if targetPlayer == nil {
|
|
logger.Error("apply add friend target player is nil, uid: %v", targetUid)
|
|
return
|
|
}
|
|
_, applyExist := targetPlayer.FriendApplyList[player.PlayerID]
|
|
_, friendExist := targetPlayer.FriendList[player.PlayerID]
|
|
if applyExist || friendExist {
|
|
logger.Error("friend or apply already exist, uid: %v", player.PlayerID)
|
|
return
|
|
}
|
|
targetPlayer.FriendApplyList[player.PlayerID] = true
|
|
USER_MANAGER.SaveTempOfflineUser(targetPlayer)
|
|
}
|
|
return
|
|
}
|
|
|
|
_, applyExist := targetPlayer.FriendApplyList[player.PlayerID]
|
|
_, friendExist := targetPlayer.FriendList[player.PlayerID]
|
|
if applyExist || friendExist {
|
|
logger.Error("friend or apply already exist, uid: %v", player.PlayerID)
|
|
return
|
|
}
|
|
targetPlayer.FriendApplyList[player.PlayerID] = true
|
|
|
|
// 目标玩家在线则通知
|
|
askAddFriendNotify := &proto.AskAddFriendNotify{
|
|
TargetUid: player.PlayerID,
|
|
}
|
|
askAddFriendNotify.TargetFriendBrief = &proto.FriendBrief{
|
|
Uid: player.PlayerID,
|
|
Nickname: player.NickName,
|
|
Level: player.PropertiesMap[constant.PLAYER_PROP_PLAYER_LEVEL],
|
|
ProfilePicture: &proto.ProfilePicture{AvatarId: player.HeadImage},
|
|
WorldLevel: player.PropertiesMap[constant.PLAYER_PROP_PLAYER_WORLD_LEVEL],
|
|
Signature: player.Signature,
|
|
OnlineState: proto.FriendOnlineState_FRIEND_ONLINE,
|
|
IsMpModeAvailable: true,
|
|
LastActiveTime: player.OfflineTime,
|
|
NameCardId: player.NameCard,
|
|
Param: (uint32(time.Now().Unix()) - player.OfflineTime) / 3600 / 24,
|
|
IsGameSource: true,
|
|
PlatformType: proto.PlatformType_PC,
|
|
}
|
|
g.SendMsg(cmd.AskAddFriendNotify, targetPlayer.PlayerID, targetPlayer.ClientSeq, askAddFriendNotify)
|
|
}
|
|
|
|
func (g *Game) DealAddFriendReq(player *model.Player, payloadMsg pb.Message) {
|
|
req := payloadMsg.(*proto.DealAddFriendReq)
|
|
targetUid := req.TargetUid
|
|
result := req.DealAddFriendResult
|
|
|
|
agree := false
|
|
if result == proto.DealAddFriendResultType_DEAL_ADD_FRIEND_ACCEPT {
|
|
agree = true
|
|
}
|
|
if agree {
|
|
player.FriendList[targetUid] = true
|
|
}
|
|
delete(player.FriendApplyList, targetUid)
|
|
|
|
dealAddFriendRsp := &proto.DealAddFriendRsp{
|
|
TargetUid: targetUid,
|
|
DealAddFriendResult: result,
|
|
}
|
|
g.SendMsg(cmd.DealAddFriendRsp, player.PlayerID, player.ClientSeq, dealAddFriendRsp)
|
|
|
|
if agree {
|
|
targetPlayer := USER_MANAGER.GetOnlineUser(targetUid)
|
|
if targetPlayer == nil {
|
|
// 非本地玩家
|
|
if USER_MANAGER.GetRemoteUserOnlineState(targetUid) {
|
|
// 远程在线玩家
|
|
gsAppId := USER_MANAGER.GetRemoteUserGsAppId(targetUid)
|
|
MESSAGE_QUEUE.SendToGs(gsAppId, &mq.NetMsg{
|
|
MsgType: mq.MsgTypeServer,
|
|
EventId: mq.ServerAddFriendNotify,
|
|
ServerMsg: &mq.ServerMsg{
|
|
AddFriendInfo: &mq.AddFriendInfo{
|
|
OriginInfo: &mq.OriginInfo{
|
|
CmdName: "DealAddFriendReq",
|
|
UserId: player.PlayerID,
|
|
},
|
|
TargetUserId: targetUid,
|
|
ApplyPlayerOnlineInfo: &mq.UserBaseInfo{
|
|
UserId: player.PlayerID,
|
|
},
|
|
},
|
|
},
|
|
})
|
|
} else {
|
|
// 全服离线玩家
|
|
targetPlayer := USER_MANAGER.LoadTempOfflineUser(targetUid, true)
|
|
if targetPlayer == nil {
|
|
logger.Error("apply add friend target player is nil, uid: %v", targetUid)
|
|
return
|
|
}
|
|
targetPlayer.FriendList[player.PlayerID] = true
|
|
USER_MANAGER.SaveTempOfflineUser(targetPlayer)
|
|
}
|
|
return
|
|
}
|
|
targetPlayer.FriendList[player.PlayerID] = true
|
|
}
|
|
}
|
|
|
|
func (g *Game) GetOnlinePlayerListReq(player *model.Player, payloadMsg pb.Message) {
|
|
count := 0
|
|
getOnlinePlayerListRsp := &proto.GetOnlinePlayerListRsp{
|
|
PlayerInfoList: make([]*proto.OnlinePlayerInfo, 0),
|
|
}
|
|
getOnlinePlayerListRsp.PlayerInfoList = append(getOnlinePlayerListRsp.PlayerInfoList, &proto.OnlinePlayerInfo{
|
|
Uid: BigWorldAiUid,
|
|
Nickname: BigWorldAiName,
|
|
PlayerLevel: 1,
|
|
MpSettingType: proto.MpSettingType_MP_SETTING_ENTER_AFTER_APPLY,
|
|
NameCardId: 210001,
|
|
Signature: BigWorldAiSign,
|
|
ProfilePicture: &proto.ProfilePicture{AvatarId: 10000007},
|
|
CurPlayerNumInWorld: 1,
|
|
})
|
|
count++
|
|
onlinePlayerList := make([]*model.Player, 0)
|
|
// 优先获取本地的在线玩家
|
|
for _, onlinePlayer := range USER_MANAGER.GetAllOnlineUserList() {
|
|
if onlinePlayer.PlayerID == player.PlayerID {
|
|
continue
|
|
}
|
|
if g.IsMainGs() && onlinePlayer.PlayerID == g.GetAi().PlayerID {
|
|
continue
|
|
}
|
|
onlinePlayerList = append(onlinePlayerList, onlinePlayer)
|
|
count++
|
|
if count >= 50 {
|
|
break
|
|
}
|
|
}
|
|
if count < 50 {
|
|
// 本地不够时获取远程的在线玩家
|
|
for _, onlinePlayer := range USER_MANAGER.GetRemoteOnlineUserList(50 - count) {
|
|
if onlinePlayer.PlayerID == player.PlayerID {
|
|
continue
|
|
}
|
|
onlinePlayerList = append(onlinePlayerList, onlinePlayer)
|
|
count++
|
|
if count >= 50 {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
for _, onlinePlayer := range onlinePlayerList {
|
|
onlinePlayerInfo := g.PacketOnlinePlayerInfo(onlinePlayer)
|
|
getOnlinePlayerListRsp.PlayerInfoList = append(getOnlinePlayerListRsp.PlayerInfoList, onlinePlayerInfo)
|
|
}
|
|
g.SendMsg(cmd.GetOnlinePlayerListRsp, player.PlayerID, player.ClientSeq, getOnlinePlayerListRsp)
|
|
}
|
|
|
|
func (g *Game) GetOnlinePlayerInfoReq(player *model.Player, payloadMsg pb.Message) {
|
|
req := payloadMsg.(*proto.GetOnlinePlayerInfoReq)
|
|
targetUid, ok := req.PlayerId.(*proto.GetOnlinePlayerInfoReq_TargetUid)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
targetPlayer, online, _ := USER_MANAGER.LoadGlobalPlayer(targetUid.TargetUid)
|
|
if targetPlayer == nil || !online {
|
|
g.SendError(cmd.GetOnlinePlayerInfoRsp, player, &proto.GetOnlinePlayerInfoRsp{}, proto.Retcode_RET_PLAYER_NOT_ONLINE)
|
|
return
|
|
}
|
|
|
|
g.SendMsg(cmd.GetOnlinePlayerInfoRsp, player.PlayerID, player.ClientSeq, &proto.GetOnlinePlayerInfoRsp{
|
|
TargetUid: targetUid.TargetUid,
|
|
TargetPlayerInfo: g.PacketOnlinePlayerInfo(targetPlayer),
|
|
})
|
|
}
|
|
|
|
func (g *Game) PacketOnlinePlayerInfo(player *model.Player) *proto.OnlinePlayerInfo {
|
|
world := WORLD_MANAGER.GetWorldByID(player.WorldId)
|
|
worldPlayerNum := uint32(1)
|
|
if world != nil {
|
|
worldPlayerNum = uint32(world.GetWorldPlayerNum())
|
|
} else {
|
|
// TODO 远程玩家的世界内人数
|
|
worldPlayerNum = 1
|
|
}
|
|
onlinePlayerInfo := &proto.OnlinePlayerInfo{
|
|
Uid: player.PlayerID,
|
|
Nickname: player.NickName,
|
|
PlayerLevel: player.PropertiesMap[constant.PLAYER_PROP_PLAYER_LEVEL],
|
|
MpSettingType: proto.MpSettingType(player.PropertiesMap[constant.PLAYER_PROP_PLAYER_MP_SETTING_TYPE]),
|
|
NameCardId: player.NameCard,
|
|
Signature: player.Signature,
|
|
ProfilePicture: &proto.ProfilePicture{AvatarId: player.HeadImage},
|
|
CurPlayerNumInWorld: worldPlayerNum,
|
|
}
|
|
return onlinePlayerInfo
|
|
}
|
|
|
|
// 跨服添加好友通知
|
|
|
|
func (g *Game) ServerAddFriendNotify(addFriendInfo *mq.AddFriendInfo) {
|
|
switch addFriendInfo.OriginInfo.CmdName {
|
|
case "AskAddFriendReq":
|
|
targetPlayer := USER_MANAGER.GetOnlineUser(addFriendInfo.TargetUserId)
|
|
if targetPlayer == nil {
|
|
logger.Error("player is nil, uid: %v", addFriendInfo.TargetUserId)
|
|
return
|
|
}
|
|
_, applyExist := targetPlayer.FriendApplyList[addFriendInfo.ApplyPlayerOnlineInfo.UserId]
|
|
_, friendExist := targetPlayer.FriendList[addFriendInfo.ApplyPlayerOnlineInfo.UserId]
|
|
if applyExist || friendExist {
|
|
logger.Error("friend or apply already exist, uid: %v", addFriendInfo.ApplyPlayerOnlineInfo.UserId)
|
|
return
|
|
}
|
|
targetPlayer.FriendApplyList[addFriendInfo.ApplyPlayerOnlineInfo.UserId] = true
|
|
|
|
// 目标玩家在线则通知
|
|
askAddFriendNotify := &proto.AskAddFriendNotify{
|
|
TargetUid: addFriendInfo.ApplyPlayerOnlineInfo.UserId,
|
|
}
|
|
askAddFriendNotify.TargetFriendBrief = &proto.FriendBrief{
|
|
Uid: addFriendInfo.ApplyPlayerOnlineInfo.UserId,
|
|
Nickname: addFriendInfo.ApplyPlayerOnlineInfo.Nickname,
|
|
Level: addFriendInfo.ApplyPlayerOnlineInfo.PlayerLevel,
|
|
ProfilePicture: &proto.ProfilePicture{AvatarId: addFriendInfo.ApplyPlayerOnlineInfo.HeadImageId},
|
|
WorldLevel: addFriendInfo.ApplyPlayerOnlineInfo.WorldLevel,
|
|
Signature: addFriendInfo.ApplyPlayerOnlineInfo.Signature,
|
|
OnlineState: proto.FriendOnlineState_FRIEND_ONLINE,
|
|
IsMpModeAvailable: true,
|
|
LastActiveTime: 0,
|
|
NameCardId: addFriendInfo.ApplyPlayerOnlineInfo.NameCardId,
|
|
Param: 0,
|
|
IsGameSource: true,
|
|
PlatformType: proto.PlatformType_PC,
|
|
}
|
|
g.SendMsg(cmd.AskAddFriendNotify, targetPlayer.PlayerID, targetPlayer.ClientSeq, askAddFriendNotify)
|
|
case "DealAddFriendReq":
|
|
targetPlayer := USER_MANAGER.GetOnlineUser(addFriendInfo.TargetUserId)
|
|
if targetPlayer == nil {
|
|
logger.Error("player is nil, uid: %v", addFriendInfo.TargetUserId)
|
|
return
|
|
}
|
|
targetPlayer.FriendList[addFriendInfo.ApplyPlayerOnlineInfo.UserId] = true
|
|
}
|
|
}
|