290 lines
7.1 KiB
Go
290 lines
7.1 KiB
Go
package pagoda
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"go_dreamfactory/comm"
|
|
"go_dreamfactory/lego/core"
|
|
"go_dreamfactory/lego/sys/event"
|
|
"go_dreamfactory/lego/sys/mgo"
|
|
"go_dreamfactory/lego/sys/redis/pipe"
|
|
"go_dreamfactory/modules"
|
|
"go_dreamfactory/pb"
|
|
"go_dreamfactory/sys/configure"
|
|
cfg "go_dreamfactory/sys/configure/structs"
|
|
"go_dreamfactory/sys/db"
|
|
"go_dreamfactory/utils"
|
|
"sync"
|
|
|
|
"github.com/go-redis/redis/v8"
|
|
"go.mongodb.org/mongo-driver/bson/primitive"
|
|
"go.mongodb.org/mongo-driver/mongo"
|
|
"go.mongodb.org/mongo-driver/x/bsonx"
|
|
)
|
|
|
|
type ModelCycle struct {
|
|
modules.MCompModel
|
|
module *Pagoda
|
|
|
|
conflock sync.RWMutex
|
|
cycelData *pb.DBCycelData
|
|
}
|
|
|
|
func (this *ModelCycle) Init(service core.IService, module core.IModule, comp core.IModuleComp, options core.IModuleOptions) (err error) {
|
|
this.TableName = string(comm.TableCyclePagoda)
|
|
err = this.MCompModel.Init(service, module, comp, options)
|
|
this.module = module.(*Pagoda)
|
|
//创建uid索引
|
|
this.DB.CreateIndex(core.SqlTable(this.TableName), mongo.IndexModel{
|
|
Keys: bsonx.Doc{{Key: "uid", Value: bsonx.Int32(1)}},
|
|
})
|
|
return
|
|
}
|
|
|
|
func (this *ModelCycle) Start() (err error) {
|
|
err = this.MCompModel.Start()
|
|
|
|
event.RegisterGO(core.Event_ServiceStartEnd, func() {
|
|
err = this.loadCyclePagoda()
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
// 刷新全局配置
|
|
func (this *ModelCycle) loadCyclePagoda() (err error) {
|
|
var (
|
|
cycelData *pb.DBCycelData = &pb.DBCycelData{}
|
|
)
|
|
if err = this.module.ModuleTools.GetGlobalData("CirculatePagoda", cycelData); err != nil && err != mgo.MongodbNil {
|
|
this.module.Errorln(err)
|
|
return
|
|
}
|
|
|
|
if err == mgo.MongodbNil {
|
|
_, err = this.refreshCycelData()
|
|
return
|
|
}
|
|
this.conflock.Lock()
|
|
this.cycelData = cycelData
|
|
this.conflock.Unlock()
|
|
return
|
|
}
|
|
|
|
// 获取循环塔信息
|
|
func (this *ModelCycle) getCycelData() (data *pb.DBCycelData) {
|
|
var (
|
|
cycelData *pb.DBCycelData
|
|
err error
|
|
)
|
|
|
|
this.conflock.RLock()
|
|
cycelData = this.cycelData
|
|
this.conflock.RUnlock()
|
|
if cycelData == nil || cycelData.Etime < configure.Now().Unix() {
|
|
if cycelData, err = this.refreshCycelData(); err != nil {
|
|
return
|
|
}
|
|
this.conflock.Lock()
|
|
this.cycelData = cycelData
|
|
this.conflock.Unlock()
|
|
}
|
|
data = cycelData
|
|
return
|
|
}
|
|
|
|
// 刷新全局配置
|
|
func (this *ModelCycle) refreshCycelData() (data *pb.DBCycelData, err error) {
|
|
var (
|
|
conf []*cfg.GameCirculateSeasonData
|
|
day int32
|
|
index int32
|
|
curType int32 // 当前的赛季
|
|
etime int64 // 结束时间
|
|
openTime int64 // 开服时间
|
|
)
|
|
if conf, err = this.module.configure.GetCirculateSeasonLenght(); err != nil {
|
|
return
|
|
}
|
|
|
|
for _, v := range conf {
|
|
day += v.Time
|
|
}
|
|
|
|
openTime = utils.GetCurZeroTime(this.module.service.GetOpentime().Unix()) // 格式化一下时间
|
|
curday := (configure.Now().Unix() - openTime) % int64(day)
|
|
curday += 1
|
|
for _, v := range conf {
|
|
index += v.Time
|
|
if int32(curday) <= index {
|
|
curType = v.Id
|
|
etime = configure.Now().Unix() + int64(index-int32(curday))*24*3600
|
|
break
|
|
}
|
|
}
|
|
etime = utils.GetZeroTime(etime) // 格式化一下时间
|
|
data = &pb.DBCycelData{
|
|
Itype: curType,
|
|
Etime: etime,
|
|
}
|
|
this.conflock.Lock()
|
|
this.cycelData = data
|
|
this.conflock.Unlock()
|
|
this.module.ModuleTools.UpdateGlobalData("CirculatePagoda", map[string]interface{}{
|
|
"itype": data.Itype,
|
|
"etime": data.Etime,
|
|
})
|
|
tableName := fmt.Sprintf("%s-%s", db.CrossTag(), this.TableName)
|
|
// 清理缓存的redis 数据
|
|
_, err = this.DBModel.Redis.Keys(tableName)
|
|
if err == nil {
|
|
if model, err := this.module.GetCrossDBModel(this.TableName); err == nil {
|
|
err = model.Redis.Delete(tableName)
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 获取爬塔信息
|
|
func (this *ModelCycle) getPagodaCycleList(uid string) (result *pb.DBPagodaCycle, err error) {
|
|
|
|
result = &pb.DBPagodaCycle{}
|
|
if err = this.Get(uid, result); err != nil && err == mgo.MongodbNil { // 初始一条数据
|
|
data := this.getCycelData()
|
|
result.Id = primitive.NewObjectID().Hex()
|
|
result.Uid = uid
|
|
result.Itype = data.Itype
|
|
result.Data = make(map[int32]*pb.CycleData, 0)
|
|
result.Rtime = configure.Now().Unix()
|
|
result.Etime = data.Etime
|
|
err = this.Add(uid, result)
|
|
return
|
|
}
|
|
|
|
return result, err
|
|
}
|
|
|
|
func (this *ModelCycle) ModifyPagodaCycleData(uid string, data map[string]interface{}) error {
|
|
|
|
return this.Change(uid, data)
|
|
}
|
|
|
|
func (this *ModelCycle) getCrossPagodaCycleList(uid string) (result *pb.DBPagodaCycle, err error) {
|
|
var (
|
|
model *db.DBModel
|
|
)
|
|
if model, err = this.module.GetCrossDBModel(this.TableName); err != nil {
|
|
return
|
|
}
|
|
result = &pb.DBPagodaCycle{}
|
|
if err = model.Get(uid, result); err != nil && err == mgo.MongodbNil { // 初始一条数据
|
|
result.Id = primitive.NewObjectID().Hex()
|
|
result.Uid = uid
|
|
result.Rtime = configure.Now().Unix()
|
|
if err = model.Add(uid, result); err != nil {
|
|
this.module.Errorf("err:%v", err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
return result, err
|
|
}
|
|
|
|
// 修改爬塔数据信息
|
|
func (this *ModelCycle) ModifyCrossPagodaCycleData(uid string, data map[string]interface{}) error {
|
|
var (
|
|
model *db.DBModel
|
|
err error
|
|
)
|
|
if model, err = this.module.GetCrossDBModel(this.TableName); err != nil {
|
|
return err
|
|
}
|
|
return model.Change(uid, data)
|
|
}
|
|
|
|
// 创建一个新的塔数据
|
|
func (this *ModelCycle) addCrossPagodaCycle(uId string, result *pb.DBPagodaCycle) (err error) {
|
|
var (
|
|
model *db.DBModel
|
|
)
|
|
if model, err = this.module.GetCrossDBModel(this.TableName); err != nil {
|
|
return
|
|
}
|
|
|
|
result.Id = primitive.NewObjectID().Hex()
|
|
result.Uid = uId
|
|
if err = model.Add(uId, result); err != nil {
|
|
this.module.Errorf("err:%v", err)
|
|
return
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// 获取排行榜前50的用户名单 (跨服)
|
|
func (this *ModelCycle) queryRankUser() (ranks []string, err error) {
|
|
var (
|
|
result []string
|
|
model *db.DBModel
|
|
)
|
|
if model, err = this.module.GetCrossDBModel(this.TableName); err != nil {
|
|
return
|
|
}
|
|
|
|
tableName := fmt.Sprintf("%s-%s", db.CrossTag(), this.TableName)
|
|
if result, err = model.Redis.ZRevRange(tableName, 0, comm.MaxRankNum).Result(); err != nil {
|
|
//this.module.Errorln(err)
|
|
return
|
|
}
|
|
ranks = make([]string, 0)
|
|
for i := 0; i < len(result); i += 1 {
|
|
ranks = append(ranks, result[i])
|
|
}
|
|
return
|
|
}
|
|
|
|
func (this *ModelCycle) queryPlayers(uIds []string) (result []*pb.DBCyclePagodaRecord, err error) {
|
|
var (
|
|
model *db.DBModel
|
|
)
|
|
if model, err = this.module.GetCrossDBModel(this.TableName); err != nil {
|
|
return
|
|
}
|
|
result = make([]*pb.DBCyclePagodaRecord, 0)
|
|
if _, err = model.GetByUids(uIds, &result); err != nil && err != mgo.MongodbNil {
|
|
//this.module.Errorln(err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// 六合塔记录 (存在跨服)
|
|
func (this *ModelCycle) SetCyclePagodaRankList(score int32, uid string) {
|
|
|
|
var (
|
|
pipe *pipe.RedisPipe
|
|
menbers *redis.Z
|
|
model *db.DBModel
|
|
err error
|
|
)
|
|
|
|
if model, err = this.module.GetCrossDBModel(this.TableName); err != nil {
|
|
return
|
|
}
|
|
tableName := fmt.Sprintf("%s-%s", db.CrossTag(), this.TableName)
|
|
pipe = model.Redis.RedisPipe(context.TODO())
|
|
menbers = &redis.Z{Score: float64(score), Member: uid}
|
|
|
|
if cmd := pipe.ZAdd(tableName, menbers); cmd != nil {
|
|
|
|
dock, err1 := cmd.Result()
|
|
if err1 != nil {
|
|
this.module.Errorln(dock, err1)
|
|
}
|
|
}
|
|
if _, err := pipe.Exec(); err != nil {
|
|
this.module.Errorln(err)
|
|
return
|
|
}
|
|
}
|