RoServer/RO_Server_Trunk-branch_0.1.39/roserver/game/model/role_invitation.go

package model

import (
	"rocommon/util"
	"roserver/baseserver/model"
	"roserver/baseserver/set"
	"roserver/serverproto"
)

func (this *Role) InvitationNumberGet() {
	if this.roleInvitation != nil {
		ret := this.roleInvitation.InvitationNumberGet()
		if ret != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCInvitationNumberAck{
				Error: int32(ret),
			}
			this.ReplayGate(ackMsg, true)
		}
	}
}

func (this *Role) InvitationNumberUserInfoGet(number uint64) {
	if this.roleInvitation != nil {
		ret := this.roleInvitation.InvitationNumberUserInfoGet(number)
		if ret != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCInvitationNumberUserInfoAck{
				Error: int32(ret),
			}
			this.ReplayGate(ackMsg, true)
		}
	}
}

func (this *Role) InvitationBeToMember(number, uid uint64) {
	if this.roleInvitation != nil {
		ret := this.roleInvitation.InvitationBeToMember(number, uid)
		if ret != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCInvitationBeToMemberAck{
				Error: int32(ret),
			}
			this.ReplayGate(ackMsg, true)
		}
	}
}
func (this *Role) InvitationReward(taskIdLIst []uint32) {
	if this.roleInvitation != nil {
		this.roleInvitation.InvitationReward(taskIdLIst)
	}
}

func (this *Role) InvitationClick(memberUidList []uint64) {
	if this.roleInvitation != nil {
		ret := this.roleInvitation.InvitationClick(memberUidList)
		ackMsg := &serverproto.SCInvitationDelMemberAck{
			Error: int32(ret),
		}
		this.ReplayGate(ackMsg, true)
	}
}
func (this *Role) InvitationClickReplay(replayMasterUid uint64) {
	if this.roleInvitation != nil {
		ret := this.roleInvitation.InvitationClickReplay(replayMasterUid)
		if ret != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCInvitationClickReplayAck{
				Error: int32(ret),
			}
			this.ReplayGate(ackMsg, true)
		}
	}
}

func (this *Role) InvitationDelMember(memberUidList []uint64) {
	if this.roleInvitation != nil {
		ret := this.roleInvitation.InvitationDelMember(memberUidList)
		if ret != serverproto.ErrorCode_ERROR_OK {
			ackMsg := &serverproto.SCInvitationDelMemberAck{
				Error: int32(ret),
			}
			this.ReplayGate(ackMsg, true)
		}
	}
}

const (
	Invitation_Member_Max_Num = 30
)

type RoleInvitation struct {
	SaveObject

	clickNum          int32  //拍一拍剩余次数
	selfInvitationNum uint64 //自己的邀请码
	masterUid         uint64 //导师uid
	masterEndTime     uint64
	bBaseSave         bool

	taskList map[uint32]*serverproto.InvitationTaskData
	//玩家提供的初心值记录(有的玩家会被踢出但是已经贡献了)
	memberUidList         map[uint64]*serverproto.InvitationMemberValData
	memberNum             int32
	logList               []*serverproto.InvitationLogData
	clickMemberList       []uint64
	clickReplayMasterList []uint64

	changeMemberUidList set.Interface //uint64
	changeTaskList      set.Interface //uint32
	changeLogList       []*serverproto.InvitationLogData

	tmpMasterUidBf  *serverproto.CommonPlayerBriefInfo
	tmpMasterNumber uint64
}

func newRoleInvitation(r *Role) *RoleInvitation {
	obj := &RoleInvitation{
		SaveObject: SaveObject{
			role: r,
		},
		taskList:            map[uint32]*serverproto.InvitationTaskData{},
		changeMemberUidList: set.New(set.NonThreadSafe),
		changeTaskList:      set.New(set.NonThreadSafe),
		memberUidList:       map[uint64]*serverproto.InvitationMemberValData{},
	}

	return obj
}

func (this *RoleInvitation) Load(ms interface{}) bool {
	return true
}

func (this *RoleInvitation) LoadOther(msg interface{}) bool {
	info := msg.(*serverproto.RoleInvitation)
	if info == nil {
		this.clickNum = model.GlobalInvitationClickNum
		this.SetDirty(true)
		return true
	}
	for idx := 0; idx < len(info.TaskList); idx++ {
		this.taskList[info.TaskList[idx].TaskId] = info.TaskList[idx]
	}
	for idx := 0; idx < len(info.MemberUidList); idx++ {
		this.memberUidList[info.MemberUidList[idx].Uid] = info.MemberUidList[idx]
		if !info.MemberUidList[idx].State {
			this.memberNum++
		}
	}

	this.logList = info.LogList
	this.clickMemberList = info.ClickMemberList
	this.clickReplayMasterList = info.ClickReplayMasterList

	this.clickNum = info.ClickNum
	this.selfInvitationNum = info.SelfInvitationNumber
	this.masterUid = info.MasterUid
	this.masterEndTime = info.MasterEndTime

	return true
}

func (this *RoleInvitation) StartupNtf() {
	ntfMsg := &serverproto.SCInvitationStartupNtf{
		InvitationInfo: &serverproto.RoleInvitation{
			ClickNum:              this.clickNum,
			SelfInvitationNumber:  this.selfInvitationNum,
			MasterUid:             this.masterUid,
			LogList:               this.logList,
			ClickMemberList:       this.clickMemberList,
			ClickReplayMasterList: this.clickReplayMasterList,
		},
	}
	for _, uidData := range this.memberUidList {
		if uidData.State {
			continue
		}
		ntfMsg.InvitationInfo.MemberUidList = append(ntfMsg.InvitationInfo.MemberUidList, uidData)
	}
	for _, data := range this.taskList {
		ntfMsg.InvitationInfo.TaskList = append(ntfMsg.InvitationInfo.TaskList, data)
	}

	this.role.ReplayGate(ntfMsg, true)
}

func (this *RoleInvitation) Save() {
	this.SetDirty(false)
	util.DebugF("uid=%v RoleInvitation save...", this.role.GetUUid())

	saveMsg := &serverproto.SSInvitationSaveNtf{
		BaseSave:              this.bBaseSave,
		ClickNum:              this.clickNum,
		SelfInvitationNumber:  this.selfInvitationNum,
		MasterUid:             this.masterUid,
		ClickMemberList:       this.clickMemberList,
		ClickReplayMasterList: this.clickReplayMasterList,
	}
	this.bBaseSave = false

	saveMsg.MemberNum = this.memberNum
	for _, val := range this.changeMemberUidList.List() {
		memberData, ok := this.memberUidList[val.(uint64)]
		if ok {
			saveMsg.AddMemberUidList = append(saveMsg.AddMemberUidList, memberData)
		} else {
			saveMsg.DelMemberUidList = append(saveMsg.DelMemberUidList, val.(uint64))
		}
	}

	for _, val := range this.changeTaskList.List() {
		if taskData, ok := this.taskList[val.(uint32)]; ok {
			saveMsg.TaskList = append(saveMsg.TaskList, taskData)
		}
	}

	saveMsg.AddLogList = append(saveMsg.AddLogList, this.changeLogList...)
	this.role.SendDb(saveMsg)

	this.changeTaskList.Clear()
	this.changeMemberUidList.Clear()
	this.changeLogList = this.changeLogList[:0]
}

func (this *RoleInvitation) DailyReset(notify bool) {
	this.clickNum = model.GlobalInvitationClickNum
	this.clickMemberList = this.clickMemberList[:0]
	this.clickReplayMasterList = this.clickReplayMasterList[:0]

	this.bBaseSave = true
	this.SetDirty(true)

	if notify {
		dataNtfMsg := this.dataChangeNtf()
		this.role.ReplayGate(dataNtfMsg, true)
	}
}

func (this *RoleInvitation) dataChangeNtf() *serverproto.SCInvitationChangNtf {
	ntfMsg := &serverproto.SCInvitationChangNtf{
		InvitationInfo: &serverproto.RoleInvitation{
			SelfInvitationNumber:  this.selfInvitationNum,
			ClickNum:              this.clickNum,
			MasterUid:             this.masterUid,
			ClickMemberList:       this.clickMemberList,
			MasterEndTime:         this.masterEndTime,
			ClickReplayMasterList: this.clickReplayMasterList,
		},
	}
	return ntfMsg
}

func (this *RoleInvitation) setClickNum(clickNum int32) {
	this.clickNum = clickNum
	this.bBaseSave = true
	this.SetDirty(true)
}
func (this *RoleInvitation) setSelfInvitationNumber(number uint64) {
	this.selfInvitationNum = number
	this.bBaseSave = true
	this.SetDirty(true)
}
func (this *RoleInvitation) setMasterUid(masterUid uint64) {
	this.masterUid = masterUid
	this.bBaseSave = true
	this.SetDirty(true)
}
func (this *RoleInvitation) addClickMember(memberUid uint64) {
	this.clickMemberList = append(this.clickMemberList, memberUid)
	this.bBaseSave = true
	this.SetDirty(true)
}
func (this *RoleInvitation) addClickReplayMember(replayMasterUid uint64) {
	this.clickReplayMasterList = append(this.clickReplayMasterList, replayMasterUid)
	this.bBaseSave = true
	this.SetDirty(true)
}

func (this *RoleInvitation) isMember(memberUid uint64) bool {
	data, ok := this.memberUidList[memberUid]
	if ok {
		return !data.State
	}
	return false
}
func (this *RoleInvitation) getMember(memberUid uint64) *serverproto.InvitationMemberValData {
	data, ok := this.memberUidList[memberUid]
	if ok {
		return data
	}
	return nil
}

func (this *RoleInvitation) InvitationNumberGet() serverproto.ErrorCode {
	ssMsg := &serverproto.SSInvitationGenNumberReq{
		MasterUid: this.masterUid,
	}
	if this.selfInvitationNum <= 0 {
		ssMsg.GenNumber = true
	}

	this.role.SendDb(ssMsg)
	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleInvitation) OnInvitationNumberGet(number uint64, masterUid uint64) {
	if number > 0 && this.selfInvitationNum <= 0 {
		this.setSelfInvitationNumber(number)
	}

	//导师uid不合法(被解除了关系)
	if this.masterUid > 0 && masterUid == 0 {
		this.setMasterUid(0)
	}

	ntfMsg := this.dataChangeNtf()
	this.role.ReplayGate(ntfMsg, true)

	ackMsg := &serverproto.SCInvitationNumberAck{
		Error: int32(serverproto.ErrorCode_ERROR_OK),
	}
	this.role.ReplayGate(ackMsg, true)
}

func (this *RoleInvitation) InvitationNumberUserInfoGet(number uint64) serverproto.ErrorCode {
	if number <= 100000 {
		return serverproto.ErrorCode_ERROR_INVITATION_NUMBER_INVALID
	}

	//cd time
	if this.masterEndTime > util.GetTimeMilliseconds() {
		return serverproto.ErrorCode_ERROR_INVITATION_MASTER_END_TIME
	}

	//已经成为其他玩家的学员
	if this.masterUid > 0 {
		return serverproto.ErrorCode_ERROR_INVITATION_HAS_MASTER
	}

	//根据邀请码查询玩家信息
	ssMsg := &serverproto.SSInvitationNumberUserInfoReq{
		Number: number,
	}
	this.role.SendDb(ssMsg)
	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleInvitation) OnInvitationNumberUserInfoGet(msg *serverproto.SSInvitationNumberUserInfoAck) {
	ackMsg := &serverproto.SCInvitationNumberUserInfoAck{
		Error: int32(serverproto.ErrorCode_ERROR_OK),
		Brief: msg.Brief,
	}
	if msg.Error != int32(serverproto.ErrorCode_ERROR_OK) {
		ackMsg.Error = msg.Error
	} else {
		if msg.MemberNum >= Invitation_Member_Max_Num {
			ackMsg.Error = int32(serverproto.ErrorCode_ERROR_INVITATION_NUM_LIMIT)
		}
		this.tmpMasterNumber = msg.Number
		this.tmpMasterUidBf = msg.Brief
	}

	this.role.ReplayGate(ackMsg, true)
}

func (this *RoleInvitation) InvitationBeToMember(number, uid uint64) serverproto.ErrorCode {
	//已经成为其他玩家的学员
	if this.masterUid > 0 {
		return serverproto.ErrorCode_ERROR_INVITATION_HAS_MASTER
	}

	//cd time
	if this.masterEndTime > util.GetTimeMilliseconds() {
		return serverproto.ErrorCode_ERROR_INVITATION_MASTER_END_TIME
	}

	if number == this.tmpMasterNumber && this.tmpMasterUidBf != nil && uid == this.tmpMasterUidBf.Uid {
		ssMsg := &serverproto.SSInvitationBeToMemberReq{
			MasterNumber: number,
			MasterUid:    uid,
			SelfUid: &serverproto.InvitationMemberValData{
				Uid:           this.role.GetUUid(),
				Level:         this.role.GetRoleLevel(),
				TotalRecharge: this.role.GetTotalRecharge(),
			},
		}
		this.role.SendSocial(ssMsg)
		return serverproto.ErrorCode_ERROR_OK
	}
	return serverproto.ErrorCode_ERROR_INVITATION_NUMBER_INVALID
}

//from social 来自其他game服务器的成为导师成员请求
//为找到对应master在线数据
//todo...
// 需要做合法性校验，如果中间添加学员成功但是学员设置导师UID出错，需要定期检查成员的合法性
func (this *RoleInvitation) InvitationBeToMemberSSReq(masterNumber, masterUid uint64, memberUid *serverproto.InvitationMemberValData) serverproto.ErrorCode {
	if this.selfInvitationNum <= 0 || this.selfInvitationNum != masterNumber || this.role.GetUUid() != masterUid {
		return serverproto.ErrorCode_ERROR_INVITATION_NUMBER_INVALID
	}

	if len(this.memberUidList) >= Invitation_Member_Max_Num {
		return serverproto.ErrorCode_ERROR_INVITATION_NUM_LIMIT
	}

	memData := this.getMember(memberUid.Uid)
	if memData == nil || memData.State {
		return serverproto.ErrorCode_ERROR_INVITATION_IS_MEMBER
	}
	if memData != nil {
		memData.Level = memberUid.Level
		memData.TotalRecharge = memberUid.TotalRecharge
		this.memberUidList[memberUid.Uid] = memData
	} else {
		this.memberUidList[memberUid.Uid] = memberUid
	}
	this.memberNum++
	this.changeMemberUidList.Add(memberUid.Uid)
	this.SetDirty(true)

	ntfMsg := this.dataChangeNtf()
	ntfMsg.InvitationInfo.MemberUidList = append(ntfMsg.InvitationInfo.MemberUidList, memberUid)
	this.role.ReplayGate(ntfMsg, true)

	return serverproto.ErrorCode_ERROR_OK
}

//玩家填写邀请码成员学员的ack
func (this *RoleInvitation) OnInvitationBeToMember(masterNumber, masterUid uint64, memberUid *serverproto.InvitationMemberValData, retCode int32) {
	switch retCode {
	case int32(serverproto.ErrorCode_ERROR_EXPEDITION_NOT_FIND_SERVICE_ID):
		//master玩家最近未上线，db操作
		ssDBMsg := &serverproto.SSInvitationBeToMemberDBReq{
			MasterNumber: masterNumber,
			MasterUid:    masterUid,
			SelfUid:      memberUid,
		}
		this.role.SendDb(ssDBMsg)
	case int32(serverproto.ErrorCode_ERROR_OK):
		//填写邀请码成为学员操作成功
		this.masterEndTime = util.GetTimeMilliseconds() + 24*60*60*1000
		this.setMasterUid(masterUid)
		//完成任务
		this.TaskCheck(serverproto.TaskType_Invitation_Number_Num, 1)

		ntfMsg := this.dataChangeNtf()
		this.role.ReplayGate(ntfMsg, true)

		ackMsg := &serverproto.SCInvitationBeToMemberAck{
			Error: retCode,
		}
		this.role.ReplayGate(ackMsg, true)
	default:
		ackMsg := &serverproto.SCInvitationBeToMemberAck{
			Error: retCode,
		}
		this.role.ReplayGate(ackMsg, true)
	}
}

//优化效率算法
//1,有序列表
//2,二分查找 和当前给定等级最低匹配元素索引
//3,统计个数
func (this *RoleInvitation) TaskCheck(taskType serverproto.TaskType, count int32) {
	//不是学员，并且也不是导师 不需要任务检测
	if this.masterUid <= 0 || len(this.memberUidList) <= 0 {
		return
	}
	typeTaskList, ok := model.ConvertInvitationTaskTypeList[int32(taskType)]
	if !ok {
		return
	}

	dataNtfMsg := this.dataChangeNtf()
	switch taskType {
	case serverproto.TaskType_Invitation_Number_Num:
		for idx := 0; idx < len(typeTaskList); idx++ {
			cfgData := typeTaskList[idx]
			taskData, ok := this.taskList[cfgData.TaskId]
			if !ok {
				taskData = &serverproto.InvitationTaskData{
					TaskId:           cfgData.TaskId,
					CompleteMaxCount: cfgData.CompleteNum,
				}
				this.taskList[taskData.TaskId] = taskData
			}
			if taskData.RewardCount >= taskData.CompleteMaxCount {
				continue
			}

			taskData.Progress += count
			this.changeTaskList.Add(taskData.TaskId)
			bRet := this.taskConditionCheck(taskData, cfgData.ConditionList[int32(taskType)], taskType)
			if bRet {
				dataNtfMsg.InvitationInfo.TaskList = append(dataNtfMsg.InvitationInfo.TaskList, taskData)
			}
			this.SetDirty(true)
		}
	case serverproto.TaskType_Invitation_Base_Level_Num:
		fallthrough
	case serverproto.TaskType_Invitation_Recharge_Num:
		for idx := 0; idx < len(typeTaskList); idx++ {
			cfgData := typeTaskList[idx]
			taskData, ok := this.taskList[cfgData.TaskId]
			if !ok {
				taskData = &serverproto.InvitationTaskData{
					TaskId:           cfgData.TaskId,
					CompleteMaxCount: cfgData.CompleteNum,
				}
				this.taskList[taskData.TaskId] = taskData
			}
			if taskData.RewardCount >= taskData.CompleteMaxCount {
				continue
			}

			bRet := this.taskConditionCheck(taskData, cfgData.ConditionList[int32(taskType)], taskType)
			if bRet {
				dataNtfMsg.InvitationInfo.TaskList = append(dataNtfMsg.InvitationInfo.TaskList, taskData)
			}
		}
	}
}

func (this *RoleInvitation) taskConditionCheck(taskData *serverproto.InvitationTaskData, conditionList []int32, taskType serverproto.TaskType) bool {
	switch taskType {
	case serverproto.TaskType_Invitation_Number_Num:
		targetNum := conditionList[1]
		newRewardCount := int32(taskData.Progress / targetNum)
		if taskData.RewardCount != newRewardCount {
			taskData.RewardCount = newRewardCount
			return true
		}
	case serverproto.TaskType_Invitation_Base_Level_Num:
		baseLevel := conditionList[1]
		targetNum := conditionList[2]
		curNum := this.taskConditionLevelNum(baseLevel)
		if taskData.Progress < curNum {
			taskData.Progress = curNum
			this.SetDirty(true)
			this.changeTaskList.Add(taskData.TaskId)

			newRewardCount := int32(taskData.Progress / targetNum)
			if taskData.RewardCount != newRewardCount {
				taskData.RewardCount = newRewardCount
				return true
			}
		}
	case serverproto.TaskType_Invitation_Recharge_Num:
		rechargeNum := conditionList[1]
		targetNum := conditionList[2]
		curNum := this.taskConditionRechargeNum(float32(rechargeNum))
		if taskData.Progress < curNum {
			taskData.Progress = curNum
			this.SetDirty(true)
			this.changeTaskList.Add(taskData.TaskId)

			newRewardCount := int32(taskData.Progress / targetNum)
			if taskData.RewardCount != newRewardCount {
				taskData.RewardCount = newRewardCount
				return true
			}
		}
	}
	return false
}

func (this *RoleInvitation) taskConditionLevelNum(baseLevel int32) int32 {
	var retNum int32 = 0
	for _, val := range this.memberUidList {
		if val.Level >= baseLevel {
			retNum++
		}
	}
	return retNum
}

func (this *RoleInvitation) taskConditionRechargeNum(rechargeNum float32) int32 {
	var retNum int32 = 0
	for _, val := range this.memberUidList {
		if val.TotalRecharge >= rechargeNum {
			retNum++
		}
	}
	return retNum
}

//等级,充值等数据变更时通知导师
func (this *RoleInvitation) InvitationNoticeMaster(noticeParam *serverproto.KeyValueType) {
	if this.masterUid > 0 && this.selfInvitationNum > 0 {
		ntfMsg := &serverproto.SSInvitationMemberNoticeMasterReq{
			SelfUid:   this.role.GetUUid(),
			MasterUid: this.masterUid,
		}
		this.role.SendSocial(ntfMsg)
	}
}

//成员等级,充值等数据变更时导师收到的通知
func (this *RoleInvitation) OnInvitationNoticeMaster(noticeMsg *serverproto.SSInvitationMemberNoticeMasterReq) {
	memberData := this.getMember(noticeMsg.SelfUid)
	if memberData == nil || memberData.State {
		util.InfoF("uid=%v OnInvitationNoticeMaster not member member=%v param=%v", this.role.GetUUid(), noticeMsg.SelfUid, *noticeMsg.Param)
		return
	}
	if noticeMsg.Param.Key == int32(serverproto.TaskType_Invitation_Base_Level_Num) {
		memberData.Level = noticeMsg.Param.Value
	} else if noticeMsg.Param.Key == int32(serverproto.TaskType_Invitation_Recharge_Num) {
		memberData.TotalRecharge = float32(noticeMsg.Param.Value)
	}

	this.TaskCheck((serverproto.TaskType)(noticeMsg.Param.Key), 0)
}

func (this *RoleInvitation) InvitationClick(memberUidList []uint64) serverproto.ErrorCode {
	if this.clickNum <= 0 {
		return serverproto.ErrorCode_ERROR_INVITATION_NO_CLICK
	}

	var addItemList = map[int32]int32{}
	tmpClickNum := this.clickNum
	if len(memberUidList) > 0 {
		for idx := 0; idx < len(memberUidList); idx++ {
			if !this.isMember(memberUidList[idx]) {
				continue
			}
			bFind := false
			for k := 0; k < len(this.clickMemberList); k++ {
				if memberUidList[idx] == this.clickMemberList[k] {
					bFind = true
					break
				}
			}
			if !bFind {
				tmpClickNum--
				this.clickMemberList = append(this.clickMemberList, memberUidList[idx])
				addItemList[int32(serverproto.ResType_Res_Invitation)] += model.GlobalInvitationClickMasterRes
				this.sendClickChatMsg(memberUidList[idx])

				if tmpClickNum <= 0 {
					break
				}
			}
		}
	} else {
		//一键拍一拍
		for key := range this.memberUidList {
			bFind := false
			for k := 0; k < len(this.clickMemberList); k++ {
				if key == this.clickMemberList[k] {
					bFind = true
					break
				}
			}
			if !bFind {
				tmpClickNum--
				this.clickMemberList = append(this.clickMemberList, key)
				addItemList[int32(serverproto.ResType_Res_Invitation)] += model.GlobalInvitationClickMasterRes
				this.sendClickChatMsg(key)

				if tmpClickNum <= 0 {
					break
				}
			}
		}
	}

	if len(addItemList) > 0 {
		this.role.roleBag.AddItemList(addItemList, AddItemST{AddFrom: AddFrom_Invitation, Notify: true})
	}

	if this.clickNum != tmpClickNum {
		this.setClickNum(tmpClickNum)

		dataNtfMsg := this.dataChangeNtf()
		this.role.ReplayGate(dataNtfMsg, true)

		return serverproto.ErrorCode_ERROR_OK
	}
	return serverproto.ErrorCode_ERROR_INVITATION_NO_MEMBER_CLICK
}

func (this *RoleInvitation) sendClickChatMsg(targetUid uint64) {
	clickChatMsg := &serverproto.CSChatMessageReq{
		TargetId: targetUid,
		Type:     int32(serverproto.ChatMessageType_CMT_PERSONAL),
		Message: &serverproto.ChatMessageInfo{
			SendTime: util.GetTimeMilliseconds(),
			SubType:  int32(serverproto.ChatMessageSubType_CMT_SUB_TYPE_Invitation),
		},
	}
	this.role.GetRoleChat().SendMsg(targetUid, int32(serverproto.ChatMessageType_CMT_PERSONAL), clickChatMsg, true)
}

func (this *RoleInvitation) InvitationClickReplay(replayMasterUid uint64) serverproto.ErrorCode {
	for idx := 0; idx < len(this.clickReplayMasterList); idx++ {
		if this.clickReplayMasterList[idx] == replayMasterUid {
			return serverproto.ErrorCode_ERROR_INVITATION_CLICK_REPLAY
		}
	}
	this.addClickReplayMember(replayMasterUid)

	var addItemList = map[int32]int32{}
	addItemList[int32(serverproto.ResType_Res_Invitation)] += model.GlobalInvitationClickMemberRes
	this.role.roleBag.AddItemList(addItemList, AddItemST{AddFrom: AddFrom_Invitation, Notify: true})

	ackMsg := &serverproto.SCInvitationClickReplayAck{
		Error: int32(serverproto.ErrorCode_ERROR_OK),
	}
	ackMsg.RewardItemList = append(ackMsg.RewardItemList,
		&serverproto.KeyValueType{Key: int32(serverproto.ResType_Res_Invitation), Value: model.GlobalInvitationClickMemberRes})
	return serverproto.ErrorCode_ERROR_OK
}

func (this *RoleInvitation) InvitationDelMember(delMemberUidList []uint64) serverproto.ErrorCode {
	if len(delMemberUidList) > Invitation_Member_Max_Num {
		return serverproto.ErrorCode_ERROR_FAIL
	}

	dataNtfMsg := this.dataChangeNtf()
	ssDelMsg := &serverproto.SSInvitationDelMemberNtf{
		MasterUid: this.role.GetUUid(),
	}
	for idx := 0; idx < len(delMemberUidList); idx++ {
		delUid := delMemberUidList[idx]
		if delUid == 0 || delUid == this.role.GetUUid() {
			continue
		}
		if !this.isMember(delUid) {
			continue
		}
		delete(this.memberUidList, delUid)
		this.memberNum--
		if this.memberNum < 0 {
			this.memberNum = 0
		}
		this.changeMemberUidList.Add(delUid)
		this.SetDirty(true)

		dataNtfMsg.DelMemberUidList = append(dataNtfMsg.DelMemberUidList, delUid)
		ssDelMsg.DelMemberList = append(ssDelMsg.DelMemberList, delUid)
	}

	if len(dataNtfMsg.DelMemberUidList) > 0 {
		this.role.ReplayGate(dataNtfMsg, true)
	}
	if len(ssDelMsg.DelMemberList) > 0 {
		this.role.SendSocial(ssDelMsg)

		AddMailOnlineAndOffline(ssDelMsg.DelMemberList, model.GlobalMailIdInvitationDelMember, int32(serverproto.MailType_MailType_Invitation),
			nil, []int32{int32(util.GetTimeSeconds())}, "", "")
	}

	return serverproto.ErrorCode_ERROR_OK
}

//通知学员解除关系
func (this *RoleInvitation) OnInvitationDelFromMaster(masterUid uint64) {
	if this.masterUid != 0 && this.masterUid == masterUid {
		this.setMasterUid(0)

		dataNtfMsg := this.dataChangeNtf()
		this.role.ReplayGate(dataNtfMsg, true)
	}
}

func (this *RoleInvitation) InvitationReward(taskIdList []uint32) {
	ackMsg := &serverproto.SCInvitationTaskRewardAck{
		Error: int32(serverproto.ErrorCode_ERROR_OK),
	}

	dataNtfMsg := this.dataChangeNtf()
	var addItemList = map[int32]int32{}
	for idx := 0; idx < len(taskIdList); idx++ {
		taskId := taskIdList[idx]
		taskData, ok := this.taskList[taskId]
		if !ok {
			continue
		}
		delRewardCount := taskData.RewardCount - taskData.RewardedCount
		if delRewardCount <= 0 {
			continue
		}
		cfgData, ok := model.ConvertInvitationTaskList[taskId]
		if !ok {
			continue
		}

		for key, val := range cfgData.RewardList {
			addItemList[key] += val * delRewardCount
		}
		taskData.RewardedCount = taskData.RewardCount
		this.changeTaskList.Add(taskId)
		this.SetDirty(true)

		dataNtfMsg.InvitationInfo.TaskList = append(dataNtfMsg.InvitationInfo.TaskList, taskData)
		ackMsg.TaskIdList = append(ackMsg.TaskIdList, taskId)
	}

	if len(addItemList) > 0 {
		this.role.AddItemList(addItemList, AddFrom_Invitation, true)

		this.role.ReplayGate(dataNtfMsg, true)

		for key, val := range addItemList {
			ackMsg.RewardItemList = append(ackMsg.RewardItemList, &serverproto.KeyValueType{Key: key, Value: val})
		}
	}

	this.role.ReplayGate(ackMsg, true)
}