s_cherry_e/sr/nodes/map/league/league_diplomacy.go

package mapLeague

import (
	capp "f1-game/internal/cherry_app"
	"f1-game/internal/code"
	"f1-game/internal/constant"
	"f1-game/internal/data"
	"f1-game/internal/enum"
	"f1-game/internal/event"
	nameActor "f1-game/internal/name/actor"
	nameLocal "f1-game/internal/name/local"
	nameRemote "f1-game/internal/name/remote"
	"f1-game/internal/pb"
	"f1-game/internal/sessions"
	"f1-game/nodes/map/internal/db"
	leagueBase "f1-game/nodes/map/league/base"
	leagueMail "f1-game/nodes/map/league/mail"

	ctime "github.com/cherry-game/cherry/extend/time"
	cfacade "github.com/cherry-game/cherry/facade"
	cproto "github.com/cherry-game/cherry/net/proto"
)

func (p *actorLeague) initDiplomacy() {
	p.Local().Register(nameLocal.MapLeague_DiplomacyApplySend, p.diplomacyApplySend)

	p.Remote().Register(nameRemote.MapLeague_DiplomacyApply, p.diplomacyApply)
	p.Remote().Register(nameRemote.MapLeague_DiplomacyApplyHandle, p.diplomacyApplyHandle)
	p.Remote().Register(nameRemote.MapLeague_DiplomacyReject, p.diplomacyReject)
	p.Remote().Register(nameRemote.MapLeague_DiplomacyAgree, p.diplomacyAgree)

	p.Remote().Register(nameRemote.MapLeague_UmengRelieve, p.umengRelieve)
	p.Remote().Register(nameRemote.MapLeague_UmengRelieveCheck, p.umengRelieveCheck)

	p.Remote().Register(nameRemote.MapLeague_UnionRelieve, p.unionRelieve)
	p.Remote().Register(nameRemote.MapLeague_UnionRelieveCheck, p.unionRelieveCheck)
}

// 联盟外交发送申请
func (p *actorLeague) diplomacyApplySend(session *cproto.Session, req *pb.I64I32) {
	var (
		playerID      = sessions.GetPlayerID(session)
		applyLeagueID = req.Key
		applyType     = req.Value
	)

	if p.leagueID == applyLeagueID {
		p.ResponseCode(session, code.LeagueDiplomacyNoSendSelf)
		return
	}

	if ok := enum.IsNotLeagueDiplomacyType(applyType); ok {
		p.ResponseCode(session, code.IllegalArgument)
		return
	}

	leagueMemberTable, found := db.GetMapLeagueMemberTable(p.leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueMembersEmpty)
		return
	}

	// 判断玩家是否有权限
	if ok := leagueMemberTable.CheckPermission(playerID, enum.League_Permission_Diplomacy); !ok {
		p.ResponseCode(session, code.LeaguePermissionDenied)
		return
	}

	// 如果当前是加入联邦申请 且当前联盟已加入联邦
	if applyType == enum.LeagueDiplomacy_Union && p.leagueTable.Diplomacy.Union.UnionID > 0 {
		p.ResponseCode(session, code.LeagueDiplomacyUnionExist)
		return
	}

	// 如果当前是友盟申请
	if applyType == enum.LeagueDiplomacy_Umeng {
		// 判断当前发送申请联盟是否已经是友盟
		if p.leagueTable.Diplomacy.IsUmeng(applyLeagueID) {
			p.ResponseCode(session, code.LeagueDiplomacyUmengExist)
			return
		}

		// 判断友盟是否已达上限
		if p.leagueTable.Diplomacy.IsUmengFull() {
			p.ResponseCode(session, code.LeagueDiplomacyUmengFull)
			return
		}
	}

	// 判断当前申请是否已经发送过
	if found := p.leagueTable.Diplomacy.IsSendApply(applyLeagueID, applyType); found {
		p.ResponseCode(session, code.LeagueDiplomacyApplyExist)
		return
	}

	// 发送申请到目标联盟
	var (
		sendReq = &pb.I64I32{
			Key:   p.leagueID,
			Value: applyType,
		}
		path = cfacade.NewChildPath("", nameActor.League, applyLeagueID)
	)
	capp.Call(path, nameRemote.MapLeague_DiplomacyApply, sendReq)

	// 添加申请
	p.leagueTable.Diplomacy.AddSendApply(applyLeagueID, applyType)

	// 保存数据
	p.leagueTable.Save2Queue()

	// TODO 通知联盟拥有外交权限成员 新增发送申请联盟

	p.ResponseCode(session, code.OK)
}

// 解除友盟外交关系
func (p *actorLeague) umengRelieve(req *pb.I64I64) (*pb.I64, int32) {
	var (
		playerID        = req.Key
		relieveLeagueID = req.Value
	)

	leagueMemberTable, found := db.GetMapLeagueMemberTable(p.leagueID)
	if !found {
		return nil, code.LeagueMembersEmpty
	}

	if ok := leagueMemberTable.CheckPermission(playerID, enum.League_Permission_Diplomacy); !ok {
		return nil, code.LeaguePermissionDenied
	}

	// 判断是否是友盟
	umeng, found := p.leagueTable.Diplomacy.Umengs.Get(relieveLeagueID)
	if !found {
		return nil, code.LeagueDiplomacyNotUmeng
	}

	// 关系解除中
	curTime := ctime.Now().ToSecond()
	if curTime < umeng.RelieveTime {
		return nil, code.LeagueDiplomacyRelieveTime
	}

	// CallWait到发送申请的联盟处理
	var (
		// 关系解除的结束时间戳
		relieveTime = curTime + data.Const.LeagueUnionLeaveTime
		relieveReq  = &pb.I64I64{Key: p.leagueID, Value: relieveTime}
		path        = cfacade.NewChildPath("", nameActor.League, relieveLeagueID)
	)
	errCode := capp.Call(path, nameRemote.MapLeague_UmengRelieveCheck, relieveReq)
	if code.IsFail(errCode) {
		return nil, errCode
	}

	umeng.RelieveTime = relieveTime

	p.leagueTable.Save2Queue()

	resp := &pb.I64{
		Value: umeng.RelieveTime,
	}

	return resp, code.OK
}

// 解除友盟外交关系检测
func (p *actorLeague) umengRelieveCheck(req *pb.I64I64) {
	// 发起解除友盟关系联盟ID
	var (
		relieveLeagueID = req.Key
		relieveTime     = req.Value
	)

	if relieveLeagueID <= 0 {
		return
	}

	// 判断是否是友盟
	umeng, found := p.leagueTable.Diplomacy.Umengs.Get(relieveLeagueID)
	if !found {
		// TODO 看是否需要通知当前解除关系的联盟解除友盟关系
		return
	}

	// 如果当前联盟已经解除过友盟关系 且解除时间比更新的时间要小 跳过
	if umeng.RelieveTime > 0 && umeng.RelieveTime <= relieveTime {
		return
	}

	// 更新结束时间戳
	umeng.RelieveTime = relieveTime
	p.leagueTable.Save2Queue()

	// 通知在线联盟成员
	leagueBase.Service().UmengRelievePush(p.leagueID, relieveLeagueID, relieveTime)
}

// 解除联邦外交关系
func (p *actorLeague) unionRelieve(req *pb.I64) (*pb.I64, int32) {
	playerID := req.Value

	if playerID <= 0 {
		return nil, code.IllegalArgument
	}

	leagueMemberTable, found := db.GetMapLeagueMemberTable(p.leagueID)
	if !found {
		return nil, code.LeagueMembersEmpty
	}

	// 没有权限
	if ok := leagueMemberTable.CheckPermission(playerID, enum.League_Permission_Diplomacy); !ok {
		return nil, code.LeaguePermissionDenied
	}

	var (
		unionID       = p.leagueTable.Diplomacy.Union.UnionID
		unionLeagueID = p.leagueTable.Diplomacy.Union.UnionLeagueID
	)

	// 没有联邦关系
	if unionID <= 0 || unionLeagueID <= 0 {
		return nil, code.LeagueUnionNotJoin
	}

	// 关系解除中
	curTime := ctime.Now().ToSecond()
	if curTime < p.leagueTable.Diplomacy.Union.UnionRelieveTime {
		return nil, code.LeagueDiplomacyRelieveTime
	}

	var (
		unionRelieveTime = curTime + data.Const.LeagueUnionLeaveTime
		// key 解除的联邦ID value 关系解除的结束时间戳
		relieveReq = &pb.I64I64{Key: unionID, Value: unionRelieveTime}
		path       = cfacade.NewChildPath("", nameActor.League, unionLeagueID)
	)

	errCode := capp.Call(path, nameRemote.MapLeague_UnionRelieveCheck, relieveReq)
	if code.IsFail(errCode) {
		return nil, errCode
	}

	p.leagueTable.Diplomacy.Union.UnionRelieveTime = unionRelieveTime

	resp := &pb.I64{
		Value: p.leagueTable.Diplomacy.Union.UnionRelieveTime,
	}

	return resp, code.OK
}

func (p *actorLeague) unionRelieveCheck(req *pb.I64I64) {
	var (
		// 发起解除联邦关系联盟ID
		relieveUnionID = req.Key
		relieveTime    = req.Value
	)

	// 解除的联邦ID不合法
	if relieveUnionID <= 0 {
		return
	}

	if p.leagueTable.Diplomacy.Union.UnionID != relieveUnionID {
		return
	}

	// 当前关系正在解除 且结束时间比更新时间要小 不处理
	curUnionRelieveTime := p.leagueTable.Diplomacy.Union.UnionRelieveTime
	if curUnionRelieveTime > 0 && curUnionRelieveTime <= relieveTime {
		return
	}

	// 更新解除时间
	p.leagueTable.Diplomacy.Union.UnionRelieveTime = relieveTime
	p.leagueTable.Save2Queue()

	// 通知在线联盟成员
	leagueBase.Service().UnionRelievePush(p.leagueTable)
}

// 联盟外交接收到申请
func (p *actorLeague) diplomacyApply(req *pb.I64I32) {
	var (
		sendApplyLeagueID = req.Key
		applyType         = req.Value
	)

	_, found := db.GetMapLeagueTable(sendApplyLeagueID)
	if !found {
		p.Warn("league diplomacy apply fail, league not exist. sendApplyLeagueID: %d, applyType: %d", sendApplyLeagueID, applyType)
		return
	}

	// 如果是邀请加入联邦 需要判断当前是否存在联邦，如果存在则返回
	if applyType == enum.LeagueDiplomacy_Union && p.leagueTable.Diplomacy.IsUnionDiplomacy() {
		return
	}

	// 判断是否存在申请
	if found := p.leagueTable.Diplomacy.IsApplyExist(sendApplyLeagueID, applyType); found {
		return
	}

	// 添加申请
	p.leagueTable.Diplomacy.AddApply(sendApplyLeagueID, applyType)

	// 保存
	p.leagueTable.Save2Queue()

	// 推送给联盟拥有外交权限成员
	leagueBase.Service().LeagueDiplomacyApplyChangePush(p.leagueID, sendApplyLeagueID, applyType, enum.LeagueDiplomacy_ApplyAdd)
}

func (p *actorLeague) diplomacyApplyHandle(req *pb.LeagueDiplomacyHandle) (*pb.I64, int32) {
	var (
		playerID          = req.PlayerID
		sendApplyLeagueID = req.HandleLeagueID
		applyType         = req.ApplyType
		agree             = req.Agree
	)

	leagueMemberTable, found := db.GetMapLeagueMemberTable(p.leagueID)
	if !found {
		return nil, code.LeagueMembersEmpty
	}

	// 判断处理的玩家是否存在权限
	if ok := leagueMemberTable.CheckPermission(playerID, enum.League_Permission_Diplomacy); !ok {
		return nil, code.LeaguePermissionDenied
	}

	// 拒绝
	if !agree {
		resp, errCode := p.doApplyReject(sendApplyLeagueID, applyType)
		if code.IsOK(errCode) {
			mailID := int32(constant.MailID_LeagueUmengReject)
			if applyType == enum.LeagueDiplomacy_Union {
				mailID = constant.MailID_LeagueUnionReject
			}

			leagueMail.Service().SendMailWithPermission(p.leagueID, mailID, enum.League_Permission_Diplomacy, nil, resp.Value)
		}

		return nil, errCode
	}

	switch applyType {
	//友盟申请
	case enum.LeagueDiplomacy_Umeng:
		// 友盟人数已满，拒绝申请
		if p.leagueTable.Diplomacy.IsUmengFull() {
			p.doApplyReject(sendApplyLeagueID, applyType)
			return nil, code.LeagueDiplomacyUmengFull
		}
	// 联邦申请
	case enum.LeagueDiplomacy_Union:
		// 联盟已存在联邦，拒绝申请
		if p.leagueTable.Diplomacy.IsUnionDiplomacy() {
			p.doApplyReject(sendApplyLeagueID, applyType)
			return nil, code.LeagueDiplomacyUnionExist
		}
	}

	// CallWait到发送申请的联盟处理
	var (
		agreeReq = &pb.LeagueDiplomacyResult{
			LeagueID:   p.leagueID,
			LeagueName: p.leagueTable.LeagueInfo.LeagueName,
			ApplyType:  applyType,
		}
		agreeResp = &pb.I64Str{}
		path      = cfacade.NewChildPath("", nameActor.League, sendApplyLeagueID)
	)
	errCode := capp.CallWait(path, nameRemote.MapLeague_DiplomacyAgree, agreeReq, agreeResp)
	if code.IsOK(errCode) {
		mailID := int32(constant.MailID_LeagueUmengSuccess)
		if applyType == enum.LeagueDiplomacy_Umeng {
			p.leagueTable.Diplomacy.AddUmeng(sendApplyLeagueID)

			// 新增友盟推送
			leagueBase.Service().LeagueUmengChangePush(p.leagueID, true, sendApplyLeagueID)
		} else {
			// 联邦ID更新
			p.leagueTable.Diplomacy.Union.UnionID = agreeResp.Key
			p.leagueTable.Diplomacy.Union.UnionLeagueID = sendApplyLeagueID

			// 同步给联盟成员
			leagueBase.Service().LeagueUnionChangePush(p.leagueID,
				p.leagueTable.Diplomacy.Union.UnionID, p.leagueTable.Diplomacy.Union.UnionLeagueID)
			mailID = constant.MailID_LeagueUnionSuccess
		}

		// 发送外交关系建立事件
		p.PostEvent(event.NewLeagueDiplomacyFinish(p.leagueID, applyType))

		// 发送关系建立邮件
		leagueMail.Service().SendMailWithPermission(p.leagueID, mailID, enum.League_Permission_Diplomacy, nil, agreeResp.Value)
	}

	// 不管成功与否都删除申请
	p.delApplyAndPush(sendApplyLeagueID, applyType)

	p.leagueTable.Save2Queue()

	result := &pb.I64{
		Value: agreeResp.Key,
	}

	return result, errCode
}

// 执行申请拒绝
func (p *actorLeague) doApplyReject(applyLeagueID int64, applyType int32) (*pb.Str, int32) {
	// 删除接收到的申请
	p.delApplyAndPush(applyLeagueID, applyType)

	// 通知发起申请的联盟删除发起的申请
	var (
		rejectReq = &pb.LeagueDiplomacyResult{
			LeagueID:   p.leagueID,
			LeagueName: p.leagueTable.LeagueInfo.LeagueName,
			ApplyType:  applyType,
		}
		resp = &pb.Str{}
		path = cfacade.NewChildPath("", nameActor.League, applyLeagueID)
	)

	errCode := capp.CallWait(path, nameRemote.MapLeague_DiplomacyReject, rejectReq, resp)

	return resp, errCode
}

// 发送申请被拒绝处理
func (p *actorLeague) diplomacyReject(req *pb.LeagueDiplomacyResult) (*pb.Str, int32) {
	var (
		rejectLeagueID   = req.LeagueID
		rejectLeagueName = req.LeagueName
		applyType        = req.ApplyType
	)

	if success := p.leagueTable.Diplomacy.DelSendApply(rejectLeagueID, applyType); success {
		p.leagueTable.Save2Queue()

		var mailID int32
		if applyType == enum.LeagueDiplomacy_Umeng {
			mailID = constant.MailID_LeagueUmengFail
		} else {
			mailID = constant.MailID_LeagueUnionFail
		}

		// 发失败邮件通知外交人员
		leagueMail.Service().SendMailWithPermission(p.leagueID, mailID, enum.League_Permission_Diplomacy, nil, rejectLeagueName)

		// TODO 看是打开界面请求下发还是直接推送
		return &pb.Str{Value: p.leagueTable.LeagueInfo.LeagueName}, code.OK
	}

	return nil, code.LeagueDiplomacyApplyNotExist
}

// 发送的申请被通过
func (p *actorLeague) diplomacyAgree(req *pb.LeagueDiplomacyResult) (*pb.I64Str, int32) {
	var (
		agreeLeagueID   = req.LeagueID
		agreeLeagueName = req.LeagueName
		applyType       = req.ApplyType
	)

	// 判断申请是否存在
	if found := p.leagueTable.Diplomacy.IsSendApply(agreeLeagueID, applyType); !found {
		return nil, code.LeagueDiplomacyApplyNotExist
	}

	var (
		resp   = &pb.I64Str{}
		mailID = int32(constant.MailID_LeagueUmengSuccess)
	)
	// 判断是否是友盟申请 如果是友盟申请判断友盟是否已达上限
	if applyType == enum.LeagueDiplomacy_Umeng {
		// 判断友盟是否已达上限
		if p.leagueTable.Diplomacy.IsUmengFull() {
			return nil, code.LeagueDiplomacyUmengFull
		}

		// 添加到友盟列表
		p.leagueTable.Diplomacy.AddUmeng(agreeLeagueID)

		// 新增友盟推送
		leagueBase.Service().LeagueUmengChangePush(p.leagueID, true, agreeLeagueID)
	} else {
		// 判断是否存在联邦 如果存在则返回联邦ID
		if p.leagueTable.Diplomacy.IsUnionDiplomacy() {
			return nil, code.LeagueDiplomacyUnionExist
		}

		// 使用当前联盟的ID作为联邦ID
		p.leagueTable.Diplomacy.Union.UnionID = p.leagueID
		p.leagueTable.Diplomacy.Union.UnionLeagueID = agreeLeagueID
		// 返回联邦ID给同意申请的联盟
		resp.Key = p.leagueTable.Diplomacy.Union.UnionID

		// 通知在线联盟成员联邦ID变更
		leagueBase.Service().LeagueUnionChangePush(p.leagueID,
			p.leagueTable.Diplomacy.Union.UnionID, p.leagueTable.Diplomacy.Union.UnionLeagueID)

		mailID = constant.MailID_LeagueUnionSuccess
	}

	// 发送外交关系建立事件
	p.PostEvent(event.NewLeagueDiplomacyFinish(p.leagueID, applyType))

	resp.Value = p.leagueTable.LeagueInfo.LeagueName

	// 发邮件通知外交人员
	leagueMail.Service().SendMailWithPermission(p.leagueID, mailID, enum.League_Permission_Diplomacy, nil, agreeLeagueName)

	// 删除发起的申请
	p.leagueTable.Diplomacy.DelSendApply(agreeLeagueID, applyType)
	// TODO 是否需要通知联盟有外交权限的成员 还是打开界面时获取

	p.leagueTable.Save2Queue()

	return resp, code.OK
}

func (p *actorLeague) delApplyAndPush(leagueID int64, applyType int32) bool {
	// 删除接收到的申请
	success := p.leagueTable.Diplomacy.DelApply(leagueID, applyType)
	if success {

		p.leagueTable.Save2Queue()

		// 通知联盟拥有外交权限成员
		leagueBase.Service().LeagueDiplomacyApplyChangePush(p.leagueID, leagueID, applyType, enum.LeagueDiplomacy_ApplyDel)
	}

	return success
}