s_cherry_e/sr/nodes/map/league/base/serivce.go

package leagueBase

import (
	capp "f1-game/internal/cherry_app"
	"f1-game/internal/component/redis"
	"f1-game/internal/constant"
	"f1-game/internal/enum"
	"f1-game/internal/event"
	"f1-game/internal/extend/utils"
	nameRedis "f1-game/internal/name/redis"
	nameRoute "f1-game/internal/name/route"
	"f1-game/internal/pb"
	"f1-game/internal/sessions"
	mapCall "f1-game/nodes/map/internal/call"
	"f1-game/nodes/map/internal/db"
	mapFacade "f1-game/nodes/map/internal/facade"
	leagueMail "f1-game/nodes/map/league/mail"

	cstring "github.com/cherry-game/cherry/extend/string"
	ctime "github.com/cherry-game/cherry/extend/time"
	clog "github.com/cherry-game/cherry/logger"
	cproto "github.com/cherry-game/cherry/net/proto"
)

func Service() *service {
	return &service{}
}

type service struct {
	mapFacade.LeagueServiceBase[*db.MapLeagueTable]
}

// func (p *service) OnInit(leagueTable *db.MapLeagueTable) {
// }

func (p *service) Push(leagueTable *db.MapLeagueTable, session *cproto.Session) {
	// 推送联盟基础信息
	p.PushLeagueInfo(leagueTable, session)

	// 推送驻地列表
	p.LeagueResidencesPush(leagueTable, session)

	// 推送联盟地图标记
	p.MapMarkPush(leagueTable, session)
}

// 推送联盟基础信息
func (p *service) PushLeagueInfo(leagueTable *db.MapLeagueTable, session *cproto.Session) {
	var (
		playerID = sessions.GetPlayerID(session)
		leagueID = leagueTable.LeagueID
	)

	// 获取联盟盟主权限是否需要更新
	if leagueTable.LeagueInfo.LeaderID == playerID {
		leagueMemberTable, found := db.GetMapLeagueMemberTable(leagueID)
		if found {
			jobID := leagueMemberTable.GetLeagueMemberJob(playerID)
			permissions, found := leagueMemberTable.GetJobPermissions(jobID)
			if !found || len(enum.LeaguePermissionss) != len(permissions) {
				leagueMemberTable.SetLeagueJobPermission(jobID, enum.LeaguePermissionss)

				leagueMemberTable.Save2Queue()
			}
		}
	}

	rsp := &pb.LeaguePush{
		LeagueID:      leagueTable.LeagueID,
		LeagueName:    leagueTable.LeagueInfo.LeagueName,
		LeagueAbbName: leagueTable.LeagueInfo.LeagueAbbName,
	}

	// 如果申请列表存在数据
	if len(leagueTable.LeagueInfo.LeagueApplys) > 0 {
		leagueMemberTable, found := db.GetMapLeagueMemberTable(leagueID)
		if found {
			if leagueMemberTable.LeagueMember.CheckPermission(playerID, enum.League_Permission_Member) {
				rsp.RedPoint = true
			}
		}
	}

	sessions.PushWithSession(session, nameRoute.PushLeague_Info, rsp)
}

// 联盟驻地列表推送
func (p *service) LeagueResidencesPush(leagueTable *db.MapLeagueTable, session *cproto.Session) {
	build, found := leagueTable.Builds.GetByType(constant.MapBuild_LeaguePoint)
	// 不存在联盟驻地 或 驻地还没建成
	if !found || build.BuildEndTime > ctime.Now().ToMillisecond() {
		return
	}

	var (
		resp      = &pb.LeagueResidenceList{}
		playerIDs = []int64{}
	)

	for index, residence := range leagueTable.Residences {
		proto := &pb.LeagueResidence{
			Index:    index,
			PlayerID: residence.PlayerID,
		}

		playerIDs = append(playerIDs, residence.PlayerID)
		resp.List = append(resp.List, proto)
	}

	if len(playerIDs) > 0 {
		playerDataMap := redis.Game.GetPlayerDataMap(playerIDs, nameRedis.PlayerBaseFields...)
		if playerDataMap != nil {
			for _, leagueResidence := range resp.List {
				playerData := playerDataMap[leagueResidence.PlayerID]
				if playerData != nil {
					leagueResidence.PlayerName = playerData.PlayerName
				}
			}
		}
	}

	sessions.PushWithSession(session, nameRoute.PushMapLeague_Residence, resp)
}

// 联盟成员登录推送地图标记
func (p *service) MapMarkPush(leagueTable *db.MapLeagueTable, session *cproto.Session) {
	if len(leagueTable.MapMarks) <= 0 {
		return
	}

	resp := leagueTable.League.ToMapMarkListProto()

	sessions.PushWithSession(session, nameRoute.PushMapLeague_MapMark, resp)
}

// 联盟外交申请添加/删除更新
func (p *service) LeagueDiplomacyApplyChangePush(leagueID, handleLeagueID int64, applyType, changeType int32) {
	// 推送给有联盟外交权限的玩家
	leagueMemberTable, found := db.GetMapLeagueMemberTable(leagueID)
	if !found {
		clog.Warnf("league member table not exist,apply push fail. leagueID:%d, sendLeagueID:%d", leagueID, handleLeagueID)
		return
	}

	// 获取外交权限的成员玩家ID
	playerIDs := leagueMemberTable.GetMemberWithPermission(enum.League_Permission_Diplomacy)
	if len(playerIDs) <= 0 {
		return
	}

	// 获取发送申请联盟名称 // TODO 后续通过其他地方获取不要直接读取db
	handleLeagueName := ""
	handleLeagueTable, found := db.GetMapLeagueTable(handleLeagueID)
	if found {
		handleLeagueName = handleLeagueTable.LeagueInfo.LeagueName
	}

	change := &pb.LeagueDiplomacyApplyChange{
		ChangeType: changeType,
		Apply: &pb.LeagueDiplomacyApply{
			LeagueID:   handleLeagueID,
			LeagueName: handleLeagueName,
			ApplyType:  applyType,
		},
	}

	sessions.PushPlayers(playerIDs, nameRoute.PushMapLeague_DiplomacyApplyChange, change)
}

// 联盟友盟变化推送
func (p *service) LeagueUmengChangePush(curLeagueID int64, add bool, changeLeagueIDs ...int64) {
	if len(changeLeagueIDs) <= 0 {
		return
	}

	leagueMemberTable, found := db.GetMapLeagueMemberTable(curLeagueID)
	if !found {
		clog.Warnf("league member table not exist,umeng change push fail. leagueID:%d, sendLeagueIDs:%d", curLeagueID, changeLeagueIDs)
		return
	}

	resp := &pb.LeagueUmengChange{
		Add:          add,
		LeagueIDList: changeLeagueIDs,
	}

	sessions.PushPlayers(leagueMemberTable.GetLeagueMemberIDs(), nameRoute.PushMapLeague_UmengChange, resp)
}

func (p *service) LeagueUnionChangePush(leagueID, unionID, unionLeagueID int64) {
	leagueMemberTable, found := db.GetMapLeagueMemberTable(leagueID)
	if !found {
		clog.Warnf("league member table not exist,union change push fail. leagueID:%d, unionID:%d", leagueID, unionID)
		return
	}

	resp := &pb.I64I64{
		Key:   unionID,
		Value: unionLeagueID,
	}

	sessions.PushPlayers(leagueMemberTable.GetLeagueMemberIDs(), nameRoute.PushMapLeague_UnionChange, resp)
}

// 联盟关系解除定时检测
func (p *service) LeagueDiplomacyTimer(leagueID int64, nowSecond int64) {
	leagueTable, found := db.GetMapLeagueTable(leagueID)
	if !found {
		return
	}

	var (
		unionRelieveTime = leagueTable.Diplomacy.Union.UnionRelieveTime
		unionID          = leagueTable.Diplomacy.Union.UnionID
		unionLeagueID    = leagueTable.Diplomacy.Union.UnionLeagueID
		save             = false
	)

	// 联邦关系解除
	if unionRelieveTime > 0 && unionID > 0 && unionRelieveTime <= nowSecond {
		leagueTable.Diplomacy.Union.ResetUnion()
		save = true

		// 通知联盟在线成员
		p.LeagueUnionChangePush(leagueID, 0, 0)

		// 发送联邦关系解除邮件&日志
		p.SendRelationRelieveMailAndLog(leagueID, unionLeagueID, constant.MailID_LeagueUnionRelieve, enum.LeagueDiplomacy_Union)
	}

	// 友盟关系解除
	removeUmengs := leagueTable.Diplomacy.GetUmengRelieveList(nowSecond)
	if len(removeUmengs) > 0 {
		for _, umengLeagueID := range removeUmengs {
			leagueTable.Diplomacy.DelUmeng(umengLeagueID)

			// 发送友盟关系解除邮件&日志
			p.SendRelationRelieveMailAndLog(leagueID, umengLeagueID, constant.MailID_LeagueUmengRelieve, enum.LeagueDiplomacy_Umeng)
		}
		save = true

		// 通知在线的联盟成员
		p.LeagueUmengChangePush(leagueID, false, removeUmengs...)
	}

	if save {
		leagueTable.Save2Queue()
	}
}

// 发送解除关系邮件给联盟外交成员
func (p *service) SendRelationRelieveMailAndLog(curLeagueID, targetLeagueID int64, mailID, relieveType int32) {
	var targetLeagueName string
	// TODO 当前先从db获取，后续优化完再从cache中获取
	leagueTable, found := db.GetMapLeagueTable(targetLeagueID)
	if found {
		targetLeagueName = leagueTable.LeagueInfo.LeagueName
	}

	// 发邮件通知当前联盟外交人员
	leagueMail.Service().SendMailWithPermission(curLeagueID, mailID, enum.League_Permission_Diplomacy, nil, targetLeagueName)

	// 添加关系解除日志
	leagueLogTable, _ := db.GetMapLeagueLogTable(curLeagueID)
	leagueLogTable.AddLeagueLog(enum.Log_LeagueRelationBreak, utils.ToStringSlice(targetLeagueName, relieveType)...) // 0=联邦
}

// 友盟关系解除推送
func (p *service) UmengRelievePush(leagueID, umengLeagueID, umengRelieveTime int64) {
	leagueMemberTable, found := db.GetMapLeagueMemberTable(leagueID)
	if !found {
		clog.Warnf("league member table not exist,umeng relieve push fail. leagueID:%d, umengLeagueID:%d", leagueID, umengLeagueID)
		return
	}

	resp := &pb.I64I64{
		Key:   umengLeagueID,
		Value: umengRelieveTime,
	}

	sessions.PushPlayers(leagueMemberTable.GetLeagueMemberIDs(), nameRoute.PushMapLeague_UmengRelieve, resp)
}

// 友盟关系解除推送
func (p *service) UnionRelievePush(leagueTable *db.MapLeagueTable) {
	leagueMemberTable, found := db.GetMapLeagueMemberTable(leagueTable.LeagueID)
	if !found {
		clog.Warnf("league member table not exist,union relieve push fail. leagueID:%d, push:%d", leagueTable.LeagueID)
		return
	}

	push := leagueTable.Diplomacy.Union.ToUnionProto()

	sessions.PushPlayers(leagueMemberTable.GetLeagueMemberIDs(), nameRoute.PushMapLeague_UnionRelieve, push)
}

// 同步联盟声望排行榜
func (p *service) SyncLeaguePrestigeRank(leagueTable *db.MapLeagueTable, leagueMemberTable *db.MapLeagueMemberTable) {
	totalPrestige := int64(leagueMemberTable.GetMemberPrestige())
	rank := leagueTable.ToRankLeague(totalPrestige)
	mapCall.Rank.UpdateLeagueRank(enum.Rank_201, rank)
}

// 联盟盟主变更事件
func (p *service) SyncLeagueLeaderChange(leagueID, newLeaderID, oldLeaderPlayerID int64, logEnum int32) {
	// 写入日志
	var newLeaderName, oldLeaderName string
	playerNames, found := p.GetPlayerNames(oldLeaderPlayerID, newLeaderID)
	if found {
		oldLeaderName = playerNames[oldLeaderPlayerID]
		newLeaderName = playerNames[newLeaderID]
	} else {
		oldLeaderName = cstring.ToString(oldLeaderPlayerID)
		newLeaderName = cstring.ToString(newLeaderID)
	}

	capp.PostEvent(event.NewLeagueLeaderChange(leagueID, newLeaderID, newLeaderName))

	leagueLogTable, _ := db.GetMapLeagueLogTable(leagueID)
	leagueLogTable.AddLeagueLog(logEnum, oldLeaderName, newLeaderName)
}

// 联盟升级推送
func (p *service) LeagueUpgradPush(leagueTable *db.MapLeagueTable, leagueMemberTable *db.MapLeagueMemberTable) {
	notice := &pb.LeagueUpgradeNotice{
		LeagueID: leagueTable.LeagueID,
		Level:    leagueTable.LeagueInfo.Level,
		Exp:      leagueTable.LeagueInfo.Exp,
		Attrs:    leagueTable.LeagueInfo.Attrs.ToProto(),
	}

	memberIDs := leagueMemberTable.GetLeagueMemberIDs()
	for _, playerID := range memberIDs {
		session, found := sessions.GetSession(playerID)
		if found {
			sessions.PushWithSession(session, nameRoute.PushMapLeague_Upgrade, notice)
		}
	}
}

func (p *service) GetPlayerName(playerID int64) string {
	playerData := p.GetPlayerData(playerID)
	if playerData != nil {
		return playerData.PlayerName
	}

	return cstring.ToString(playerID)
}

func (p *service) GetPlayerData(playerID int64) *pb.PlayerData {
	playerData := redis.Game.GetPlayerData(playerID, nameRedis.PlayerBaseFields...)
	if playerData != nil {
		return playerData
	}

	return nil
}

func (p *service) GetPlayerNames(playerIDs ...int64) (map[int64]string, bool) {
	playerDatas := redis.Game.GetPlayerDataMap(playerIDs, nameRedis.PlayerNameFields...)
	if playerDatas == nil {
		return nil, false
	}

	playerNames := map[int64]string{}

	for _, playerData := range playerDatas {
		playerNames[playerData.PlayerID] = playerData.PlayerName
	}

	return playerNames, true
}