game_sync/worldsrv/permitmgr.go

package main

import (
	"encoding/json"
	"time"

	"mongo.games.com/goserver/core/basic"
	"mongo.games.com/goserver/core/i18n"
	"mongo.games.com/goserver/core/logger"
	"mongo.games.com/goserver/core/task"

	"mongo.games.com/game/common"
	"mongo.games.com/game/model"
)

var PermitMgrInst = new(PermitMgr)

type PermitMgr struct {
	common.BaseClockSinker
}

func (r *PermitMgr) InterestClockEvent() int {
	return 1 << common.ClockEventDay
}

func (r *PermitMgr) OnDayTimer() {
	logger.Logger.Info("(this *PermitMgr) OnDayTimer")
	now := time.Now()
	for _, v := range PlatformMgrSingleton.GetPlatforms() {
		platform := v.IdStr
		pl := PlatformMgrSingleton.GetConfig(platform).ActPermitConfig
		if pl == nil {
			continue
		}
		b := model.GetStrKVGameData(common.PermitStartTsKey + platform)
		if b == "" {
			logger.Logger.Errorf("(this *PermitMgr) OnDayTimer GetStrKVGameData not found")
			continue
		}
		se := new(model.PermitStartTs)
		if err := json.Unmarshal([]byte(b), se); err != nil {
			logger.Logger.Errorf("(this *PermitMgr) OnDayTimer json.Unmarshal err:%v", err)
			continue
		}
		logger.Logger.Tracef("(this *PermitMgr) OnDayTimer se:%+v now:%v", *se, now)
		if se.StartTs <= now.Unix() && now.Unix() < se.EndTs {
			// 在活动内
			continue
		}
		if now.Unix() < se.StartTs {
			// 活动未开始
			continue
		}
		if now.Unix() >= se.EndTs {
			// 活动结束，发送排行榜奖励
			startTs := se.StartTs
			var err error
			var list *model.FindPlayerPermitListReply
			var players []*model.PlayerBaseInfo
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				list, err = model.FindPlayerPermitList(&model.FindPlayerPermitListArgs{
					Platform: platform,
					StartTs:  startTs,
				})
				for _, vv := range list.List {
					player := PlayerMgrSington.GetPlayerBySnId(vv.SnId)
					if player != nil {
						players = append(players, &model.PlayerBaseInfo{
							SnId:        player.SnId,
							LastChannel: player.LastChannel,
						})
					} else {
						baseInfo := model.GetPlayerBaseInfo(platform, vv.SnId)
						players = append(players, baseInfo)
					}
				}
				return nil
			}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
				if err != nil {
					logger.Logger.Errorf("PermitMgr OnDayTimer FindPlayerPermitList err:%v", err)
					return
				}
				for k, player := range players {
					if player == nil {
						logger.Logger.Errorf("PermitMgr OnDayTimer FindPlayerPermitList player is nil %v", list.List[k].SnId)
						continue
					}
					curPlayer := player
					// 发送奖励
					cfg := PlatformMgrSingleton.GetPermitConfig(platform, player.LastChannel).GetRankConfig()
					rank := k + 1
					for _, rankInfo := range cfg {
						var has bool
						var items []int32
						for r := rankInfo.GetStart(); r <= rankInfo.GetEnd(); r++ {
							if rank == int(r) {
								has = true
								var awards []model.AwardItem
								for _, item := range rankInfo.GetItemId() {
									items = append(items, item.GetItemId())
									items = append(items, int32(item.GetItemNum()))
									awards = append(awards, model.AwardItem{
										Id:  item.GetItemId(),
										Num: item.GetItemNum(),
									})
								}
								if len(items) == 0 {
									break
								}
								logger.Logger.Infof("PermitMgr rank award snid:%v rank:%v", player.SnId, rank)
								// 领奖记录
								LogChannelSingleton.WriteLog(&model.BackendPermitRank{
									Platform: platform,
									StartTs:  startTs,
									SnId:     curPlayer.SnId,
									Rank:     int32(rank),
									Score:    list.List[k].Exp,
									Awards:   awards,
								})
								// 发邮件
								var newMsg *model.Message
								task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
									title := i18n.Tr("languages", "PermitAwardTitle")
									content := i18n.Tr("languages", "PermitAward", []int{rank, rank, rank, rank})
									newMsg = model.NewMessage("", 0, "", curPlayer.SnId, model.MSGTYPE_RANK_PermitReward,
										title, content, 0, 0, model.MSGSTATE_UNREAD, time.Now().Unix(), 0, "", items, platform, model.HallTienlen, nil)
									err := model.InsertMessage(platform, newMsg)
									if err != nil {
										logger.Logger.Errorf("发送邮件失败 snid:%v err:%v", curPlayer.SnId, err)
										return err
									}
									return nil
								}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
									p := PlayerMgrSington.GetPlayerBySnId(curPlayer.SnId)
									if p != nil {
										p.AddMessage(newMsg)
									}
								})).Start()
								break
							}
						}
						if has {
							break
						}
					}
				}
			})).StartByExecutor("permit_rank_award")

			// 活动已结束, 新开始
			se.StartTs = se.EndTs
			se.EndTs = se.EndTs + int64(pl.Days*24*3600)
			if now.Unix() < se.StartTs || now.Unix() >= se.EndTs {
				se.StartTs = common.GetDayStartTs(now.Unix())
				se.EndTs = se.StartTs + int64(pl.Days*24*3600)
			}
			PlatformMgrSingleton.GetConfig(platform).PermitStartTs = se.StartTs
			PlatformMgrSingleton.GetConfig(platform).PermitEndTs = se.EndTs
			for _, v := range PlayerMgrSington.playerOfPlatform[platform] {
				v.ResetPermit()
			}
			b, err := json.Marshal(se)
			if err != nil {
				logger.Logger.Errorf("(this *PermitMgr) OnDayTimer json.Marshal err:%v", err)
				continue
			}
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				model.UptStrKVGameData(common.PermitStartTsKey+platform, string(b))
				return nil
			}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
				if se.StartTs > 0 {
					LogChannelSingleton.WriteLog(&model.BackendPermitCycle{
						Platform: platform,
						StartTs:  se.StartTs,
						EndTs:    se.EndTs - 1,
					})
				}
			})).StartByExecutor("permit_start_ts")
		}
	}
}

func init() {
	common.ClockMgrSingleton.RegisterSinker(PermitMgrInst)
}