go_dreamfactory/modules/pagoda/module.go

package pagoda

import (
	"context"
	"go_dreamfactory/comm"
	"go_dreamfactory/lego/base"
	"go_dreamfactory/lego/core"
	"go_dreamfactory/lego/sys/log"
	"go_dreamfactory/lego/sys/redis/pipe"
	"go_dreamfactory/modules"
	"go_dreamfactory/pb"
	"go_dreamfactory/sys/configure"
	"go_dreamfactory/sys/db"
	"go_dreamfactory/utils"

	"github.com/go-redis/redis/v8"
)

var _ comm.IPagoda = (*Pagoda)(nil)

type Pagoda struct {
	modules.ModuleBase
	modelPagoda *ModelPagoda
	//modelSeasonPagoda *ModelSeasonPagoda
	api             *apiComp
	modulerank      *ModelRank
	configure       *configureComp
	battle          comm.IBattle
	service         base.IRPCXService
	mail            comm.Imail
	friend          comm.IFriend
	modelRacePagoda *ModelRace
}

func NewModule() core.IModule {
	return &Pagoda{}
}

func (this *Pagoda) GetType() core.M_Modules {
	return comm.ModulePagoda
}

func (this *Pagoda) Init(service core.IService, module core.IModule, options core.IModuleOptions) (err error) {
	if err = this.ModuleBase.Init(service, module, options); err != nil {
		return
	}
	this.service = service.(base.IRPCXService)
	return
}

func (this *Pagoda) OnInstallComp() {
	this.ModuleBase.OnInstallComp()
	this.api = this.RegisterComp(new(apiComp)).(*apiComp)
	this.modelPagoda = this.RegisterComp(new(ModelPagoda)).(*ModelPagoda)
	//this.modelSeasonPagoda = this.RegisterComp(new(ModelSeasonPagoda)).(*ModelSeasonPagoda)
	this.modulerank = this.RegisterComp(new(ModelRank)).(*ModelRank)
	this.configure = this.RegisterComp(new(configureComp)).(*configureComp)
	this.modelRacePagoda = this.RegisterComp(new(ModelRace)).(*ModelRace)
}

// 接口信息
func (this *Pagoda) ModifyPagodaData(uid string, data map[string]interface{}) (errdata *pb.ErrorData) {
	err := this.modelPagoda.modifyPagodaDataByObjId(uid, data)
	if err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_DBError,
			Title:   pb.ErrorCode_DBError.ToString(),
			Message: err.Error(),
		}
	}
	return
}

func (this *Pagoda) Start() (err error) {
	if err = this.ModuleBase.Start(); err != nil {
		return
	}
	var module core.IModule
	if module, err = this.service.GetModule(comm.ModuleBattle); err != nil {
		return
	}

	this.battle = module.(comm.IBattle)

	if module, err = this.service.GetModule(comm.ModuleMail); err != nil {
		return
	}
	this.mail = module.(comm.Imail)
	if module, err = this.service.GetModule(comm.ModuleFriend); err != nil {
		return
	}
	this.friend = module.(comm.IFriend)
	//this.service.RegisterFunctionName(string(comm.Rpc_ModuleSeasonPagodaReward), this.Rpc_ModuleSeasonPagodaReward)
	return
}

// 给gm 调用修改爬塔层数
func (this *Pagoda) ModifyPagodaFloor(session comm.IUserSession, d1 int32, d2 int32) (errdata *pb.ErrorData) {
	list, _ := this.modelPagoda.getPagodaList(session.GetUserId())
	//参数校验
	_, err := this.configure.GetPagodaConfBytab(d1, d2)
	if err != nil {
		errdata = &pb.ErrorData{
			Code:    pb.ErrorCode_ConfigNoFound,
			Title:   pb.ErrorCode_ConfigNoFound.ToString(),
			Message: err.Error(),
		}
		return
	}
	list.Data[d1] = d2
	list.PagodaId = d2
	mapData := make(map[string]interface{}, 0)
	mapData["data"] = list.Data
	mapData["pagodaId"] = list.PagodaId
	errdata = this.ModifyPagodaData(session.GetUserId(), mapData)
	session.SendMsg(string(this.GetType()), PagodaGetListResp, &pb.PagodaGetListResp{Data: list})

	return
}

// 查询玩家
func (this *Pagoda) CheckUserBasePagodaInfo(uid string) (data *pb.DBPagodaRecord) {

	list, _ := this.modelPagoda.getPagodaList(uid)
	if list != nil { // redis没有数据
		data = this.modulerank.getPagodaRankListByFloorid(uid, list.PagodaId)
	}
	return
}

// redis 排序 tableName:"pagodaList"
func (this *Pagoda) SetPagodaRankList(tableName string, score int32, uid string) {
	if !this.IsCross() {
		if conn, err := db.Cross(); err == nil {
			var (
				pipe    *pipe.RedisPipe = conn.Redis.RedisPipe(context.TODO())
				menbers *redis.Z
			)

			menbers = &redis.Z{Score: float64(score), Member: uid}

			if cmd := pipe.ZAdd(tableName, menbers); cmd != nil {

				dock, err1 := cmd.Result()
				if err1 != nil {
					this.Errorln(dock, err1)
				}
			}
			if _, err = pipe.Exec(); err != nil {
				this.Errorln(err)
				return
			}
		}
	}
}

//红点查询
func (this *Pagoda) Reddot(session comm.IUserSession, rid ...comm.ReddotType) (reddot map[comm.ReddotType]*pb.ReddotItem) {
	reddot = make(map[comm.ReddotType]*pb.ReddotItem)
	for _, v := range rid {
		switch v {
		case comm.Reddot6:
			reddot[comm.Reddot6] = &pb.ReddotItem{
				Rid:       int32(comm.Reddot6),
				Activated: this.CheckPoint6(session.GetUserId()),
			}
			break
		case comm.Reddot29101:
			activity, process := this.CheckPoint29101(session.GetUserId())
			reddot[comm.Reddot29101] = &pb.ReddotItem{
				Rid:       int32(comm.Reddot29101),
				Activated: activity,
				Progress:  process,
			}
			break
		}
	}
	return
}

func (this *Pagoda) CheckPoint29101(uid string) (activated bool, progress int32) {
	var (
		curWeekDay int32 //今天周几
	)
	curWeekDay = int32(configure.Now().Weekday())
	if curWeekDay == 0 {
		curWeekDay = 7
	}
	list, err := this.modelRacePagoda.getPagodaRaceList(uid)
	if err != nil {
		return
	}
	for _, v := range list.Race {
		if v.Race < 10 { // 10以内的是阵营塔
			var defeat int32
			// 校验今天是否开启
			if c, err := this.configure.GetPagodaCirculateConf(v.Race, v.Curfloor); err == nil {
				for _, v1 := range c.Openingtime {
					if curWeekDay == v1 {
						if utils.IsToday(v.Rtime) {
							defeat = v.Defeat
							return
						}
						if defeat < 10 { // 每天固定打10次
							progress += (10 - defeat)
							activated = true
						}
						break
					}
				}
			}
		}
	}
	return
}

// 红点检测
func (this *Pagoda) CheckPoint6(uid string) bool {
	list, err := this.modelPagoda.getPagodaList(uid)
	if err != nil {
		return false
	}
	maxFloor := this.configure.GetPagodaFloor(list.Type)
	if list.PagodaId < maxFloor { // 层数不够 显示红点
		return true
	}

	return true
}

func (this *Pagoda) Rpc_ModuleSeasonPagodaReward(ctx context.Context, args *pb.EmptyReq, reply *pb.EmptyResp) {
	this.Debug("Rpc_ModuleSeasonPagodaReward", log.Field{Key: "args", Value: args.String()})
	//	this.modulerank.seasonSettlement()
}

func (this *Pagoda) GetSeasonData() (endSeasonTime int64) {

	_, endSeasonTime = utils.GetMonthStartEnd() //+ int64((6-d)*3600*24)

	return endSeasonTime
}

func (this *Pagoda) CheckCompletePagoda(uid string) (bComplete bool) {

	if list, err := this.modelPagoda.getPagodaList(uid); err != nil {
		return list.Complete
	}

	return false
}
func (this *Pagoda) SetRacePagodaRankList(tableName string, score int32, uid string, objID string) {
	if !this.IsCross() {
		if conn, err := db.Cross(); err == nil {

			var (
				pipe    *pipe.RedisPipe = conn.Redis.RedisPipe(context.TODO())
				menbers *redis.Z
			)

			strKey := "pagodarace:" + uid + "-" + objID // 自定义key
			menbers = &redis.Z{Score: float64(score), Member: strKey}

			if cmd := pipe.ZAdd(tableName, menbers); cmd != nil {

				dock, err1 := cmd.Result()
				if err1 != nil {
					this.Errorln(dock, err1)
				}
			}
			if _, err := pipe.Exec(); err != nil {
				this.Errorln(err)
				return
			}

		}
	}
}

func (this *Pagoda) GMModifyRacePagoda(uid string, key int32, floor int32) {

	if race, err := this.modelRacePagoda.getPagodaRaceList(uid); err == nil {
		if _, ok := race.Race[key]; ok {
			race.Race[key].Curfloor = floor
		} else {
			race.Race[key] = &pb.RaceData{
				Race:   key,
				Task:   []int32{},
				Rtime:  configure.Now().Unix(),
				Defeat: 0,

				Curfloor: 0,
			}
			if key >= 10 {
				race.Race[key].Endtime = this.GetSeasonData()
			}
		}
		mapData := make(map[string]interface{}, 0)
		mapData["race"] = race.Race
		this.modelRacePagoda.ModifyPagodaRaceDataByObjId(uid, mapData)
		return
	}
}