RoServer/RO_Server_Trunk-branch_bt/roserver/rank/model/rank_keepsake.go

package model

import (
	"encoding/base64"
	"rocommon"
	"rocommon/service"
	"rocommon/util"
	"roserver/baseserver/model"
	"roserver/serverproto"
	"strconv"
	model2 "roserver/baseserver/model"
	model3 "roserver/db/model"
	"errors"
)


type KeepSakeCollectManager struct {
	KeepCollectCollect map[int32]*serverproto.KeepSakeCollection //key 玩家UID， value 等级
	TickTime           uint64
	ChangeList         map[int32]int32
}

func newKeepSakeCollectManager() *KeepSakeCollectManager {
	mag := &KeepSakeCollectManager{
		KeepCollectCollect: map[int32]*serverproto.KeepSakeCollection{},
	}
	mag.TickTime = 0
	mag.ChangeList = make(map[int32]int32)
	return mag
}

//1秒刷新
func (this *KeepSakeCollectManager) Update(ms uint64) {
	if this.TickTime == 0 {
		err := this.GetKeepSakeCollectFromRedis()
		if err == nil {
			this.TickTime = ms
		}
		util.InfoF("[TowerRankManger] err:%v", err)
		return
	}
	//5秒中刷新
	if this.TickTime != 0 && this.TickTime+RefreshTime < ms {
		return
	}

	//写数据库
	this.SetKeepSakeCollectToRedis()
	this.TickTime = ms
}

func (this *KeepSakeCollectManager) GetKeepSakeCollectFromRedis() error {
	if service.GetRedis() == nil {
		return errors.New("redis not ok")
	}

	keyStr := model2.KeepSakeCollectRankPrefix
	valueStr, err := service.GetRedis().HGetAll(keyStr).Result()
	if err != nil {
		util.InfoF("GetKeepSakeCollectFromRedis get keyStr=%v err=%v", keyStr, err)
		return err
	}

	for keepSakeId, keepSakeValue := range valueStr {
		val, _ := model2.Str2Num(keepSakeId)
		msgStr, err := base64.StdEncoding.DecodeString(keepSakeValue)
		if err != nil {
			util.InfoF("GetKeepSakeCollectFromRedis keepSakeValue=%v err=%v", keepSakeValue, err)
			continue
		}
		keepSakeCollect := &serverproto.KeepSakeCollection{}
		err = rocommon.GetCodec().Unmarshal(msgStr, keepSakeCollect)
		if err == nil {
			this.KeepCollectCollect[int32(val)] = keepSakeCollect
		} else {
			return err
		}
	}

	return nil
}

func (this *KeepSakeCollectManager) SetKeepSakeCollectToRedis() {
	if len(this.ChangeList) <= 0 {
		return
	}
	var count int = 0
	for keepSakeId, _ := range this.ChangeList {
		if count >= TOWEFIGHT_RANK {
			break
		}
		data, ok := this.KeepCollectCollect[keepSakeId]
		if !ok {
			continue
		}

		fieldStr := strconv.FormatUint(uint64(keepSakeId), 10)
		keyStr := model2.KeepSakeCollectRankPrefix

		err, msgStr := model2.GetEncodeMessage(data)
		if err != nil {
			util.InfoF("[SetKeepSakeCollectToRedis] err=%v", err)
		}
		ret, err := service.GetRedis().HSet(keyStr, fieldStr, msgStr).Result()
		if err != nil {
			util.InfoF("[SetKeepSakeCollectToRedis] err=%v", err, ret)
			continue
		}
		delete(this.ChangeList, keepSakeId)
		//this.ChangeList = append(this.ChangeList[:index], this.ChangeList[index+1:]...)
		count++
	}

	return
}

func (this *KeepSakeCollectManager) OnKeepSakeCollectChange(uid uint64, keepSakeId int32) {
	if uid == 0 || keepSakeId == 0 {
		return
	}
	var bChanged bool = false
	keepSakeCollect := this.KeepCollectCollect[keepSakeId]
	if keepSakeCollect == nil {
		this.KeepCollectCollect[keepSakeId] = &serverproto.KeepSakeCollection{
			Uid:       uid,
			LogTime:   int64(util.GetCurrentTime()),
		}
		bChanged = true
	} else {
		return
	}
	if bChanged == true {
		this.ChangeList[keepSakeId] = 1
	}
}

func (this *KeepSakeCollectManager) KeepSakeRankInfo(msg *serverproto.CSKeepSakeRankReq, ev rocommon.ProcEvent) {
	if msg == nil {
		return
	}
	ackMsg := &serverproto.SCKeepSakeRankAck{
		KeepSakeId: msg.KeepSakeId,
	}
	keepSakeCollect := this.KeepCollectCollect[msg.KeepSakeId]
	if keepSakeCollect == nil {
		ackMsg.Error = int32(serverproto.ErrorCode_ERROR_OK)
		model.ServiceReplay(ev, ackMsg)
		return
	}
	ackMsg.PlayerInfo = &serverproto.CommonPlayerBriefInfo{}
	ackMsg.Error = int32(serverproto.ErrorCode_ERROR_OK)
	ackMsg.KeepSakeId = msg.KeepSakeId
	ackMsg.AchievementTime = uint64(keepSakeCollect.LogTime)

	model3.GetSystemDataFromRedis(model3.RolePlayerBriefPrefix, keepSakeCollect.Uid, ackMsg.PlayerInfo)

	model.ServiceReplay(ev, ackMsg)
}