296 lines
7.8 KiB
Go
296 lines
7.8 KiB
Go
package viking
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"go_dreamfactory/comm"
|
|
"go_dreamfactory/lego/core"
|
|
"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"
|
|
"strconv"
|
|
|
|
"github.com/go-redis/redis/v8"
|
|
"go.mongodb.org/mongo-driver/bson"
|
|
"go.mongodb.org/mongo-driver/bson/primitive"
|
|
"go.mongodb.org/mongo-driver/mongo"
|
|
"go.mongodb.org/mongo-driver/x/bsonx"
|
|
)
|
|
|
|
type ModelSRank struct {
|
|
modules.MCompModel
|
|
moduleViking *Viking
|
|
}
|
|
|
|
func (this *ModelSRank) Init(service core.IService, module core.IModule, comp core.IModuleComp, options core.IModuleOptions) (err error) {
|
|
this.TableName = comm.TableVikingSRank
|
|
err = this.MCompModel.Init(service, module, comp, options)
|
|
this.moduleViking = module.(*Viking)
|
|
//创建uid索引
|
|
this.DB.CreateIndex(core.SqlTable(this.TableName), mongo.IndexModel{
|
|
Keys: bsonx.Doc{{Key: "uid", Value: bsonx.Int32(1)}},
|
|
})
|
|
return
|
|
}
|
|
|
|
// 批量查询
|
|
func (this *ModelSRank) queryPlayers(uIds []string) (result []*pb.DBVSeasonRecord, err error) {
|
|
var conn *db.DBConn
|
|
conn, err = db.Cross()
|
|
if err != nil {
|
|
return
|
|
}
|
|
result = make([]*pb.DBVSeasonRecord, 0)
|
|
model := db.NewDBModelByExpired(db.CrossTag(), comm.TableVikingSRank, conn)
|
|
if _, err = model.GetByUids(uIds, &result); err != nil && err != mgo.MongodbNil {
|
|
//this.module.Errorln(err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
func (this *ModelSRank) CheckCurSeasonData() (bLocal bool, endSeasonTime int64) {
|
|
var subTime int64
|
|
var oneSeason int64
|
|
openTime := this.moduleViking.service.GetOpentime().Unix()
|
|
// 获取第一个赛季结束的时间
|
|
oneSeason = utils.GetTodayZeroTime(openTime) //+ int64((6-d)*3600*24)
|
|
|
|
var c int32
|
|
if Continued%Cycle == 0 {
|
|
c = Continued / Cycle
|
|
} else {
|
|
c = Continued/Cycle + 1
|
|
}
|
|
|
|
if configure.Now().Unix() > oneSeason {
|
|
subTime = configure.Now().Unix() - oneSeason
|
|
subTime = subTime/(14*3600*24) + 1
|
|
}
|
|
// 只需判断当前时间是否大于第c个赛季即可
|
|
endSeasonTime = oneSeason
|
|
endSeasonTime += 14 * 3600 * 24 * int64(c)
|
|
if endSeasonTime <= configure.Now().Unix() {
|
|
endSeasonTime = oneSeason + subTime*14*3600*24
|
|
return false, endSeasonTime
|
|
}
|
|
endSeasonTime = oneSeason + subTime*14*3600*24
|
|
return true, endSeasonTime
|
|
}
|
|
|
|
// 检查上一个赛季实在本服还是在跨服
|
|
func (this *ModelSRank) CheckPreSeasonData() (bLocal bool) {
|
|
openTime := this.moduleViking.service.GetOpentime().Unix()
|
|
// 获取第一个赛季结束的时间
|
|
endSeasonTime := utils.GetTodayZeroTime(openTime) //+ int64((6-d)*3600*24)
|
|
|
|
var c int32
|
|
if Continued%Cycle == 0 {
|
|
c = Continued / Cycle
|
|
} else {
|
|
c = Continued/Cycle + 1
|
|
}
|
|
|
|
// 只需判断当前时间是否大于第c个赛季即可
|
|
endSeasonTime += 3600 * 24 * int64(Cycle*c)
|
|
if endSeasonTime <= configure.Now().Unix()-int64(Cycle*3600*24) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
// 记录数据存在跨服
|
|
func (this *ModelSRank) CheckSeasonRank(uid string, boosID int32, difficulty int32, line *pb.LineData, huihe int32) {
|
|
var (
|
|
conn_ *db.DBConn
|
|
err error
|
|
record *pb.DBVSeasonRecord
|
|
update map[string]interface{}
|
|
)
|
|
update = make(map[string]interface{}, 0)
|
|
|
|
conn_, err = db.Cross()
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
user, err := this.moduleViking.ModuleUser.GetUser(uid)
|
|
if err != nil {
|
|
return
|
|
}
|
|
model := db.NewDBModelByExpired(db.CrossTag(), comm.TableVikingSRank, conn_)
|
|
|
|
// 写入排行榜
|
|
record = &pb.DBVSeasonRecord{
|
|
Id: "",
|
|
Uinfo: &pb.BaseUserInfo{},
|
|
Data: make(map[int32]*pb.HuiheData, 0),
|
|
}
|
|
if err = model.Get(uid, record); err == mgo.MongodbNil {
|
|
record.Id = primitive.NewObjectID().Hex()
|
|
record.Uid = uid
|
|
record.Data = make(map[int32]*pb.HuiheData, 0)
|
|
record.Uinfo = &pb.BaseUserInfo{
|
|
Uid: uid,
|
|
Sid: user.Sid,
|
|
Name: user.Name,
|
|
Gender: user.Gender,
|
|
Skin: user.CurSkin,
|
|
Aframe: user.Curaframe,
|
|
Title: user.Curtitle,
|
|
Lv: user.Lv,
|
|
}
|
|
mpLine := make(map[int32]*pb.LineData, 0)
|
|
mpLine[difficulty] = line
|
|
tmp := make(map[int32]int32, 0)
|
|
tmp[difficulty] = huihe
|
|
|
|
if _, ok := record.Data[boosID]; !ok {
|
|
record.Data[boosID] = &pb.HuiheData{
|
|
Huihe: tmp,
|
|
Maxnandu: difficulty,
|
|
Line: mpLine,
|
|
}
|
|
} else {
|
|
if record.Data[boosID].Maxnandu < difficulty {
|
|
record.Data[boosID].Maxnandu = difficulty
|
|
}
|
|
}
|
|
|
|
model.Add(uid, record)
|
|
} else if err == nil {
|
|
record.Uinfo = &pb.BaseUserInfo{
|
|
Uid: uid,
|
|
Sid: user.Sid,
|
|
Name: user.Name,
|
|
Gender: user.Gender,
|
|
Skin: user.CurSkin,
|
|
Aframe: user.Curaframe,
|
|
Title: user.Curtitle,
|
|
Lv: user.Lv,
|
|
}
|
|
update["uinfo"] = record.Uinfo
|
|
if _, ok := record.Data[boosID]; !ok {
|
|
mpLine := make(map[int32]*pb.LineData, 0)
|
|
mpLine[difficulty] = line
|
|
tmp := make(map[int32]int32, 0)
|
|
tmp[difficulty] = huihe
|
|
record.Data[boosID] = &pb.HuiheData{
|
|
Huihe: tmp,
|
|
Maxnandu: difficulty,
|
|
Line: mpLine,
|
|
}
|
|
} else {
|
|
if record.Data[boosID].Maxnandu < difficulty {
|
|
record.Data[boosID].Maxnandu = difficulty
|
|
} else {
|
|
if record.Data[boosID].Huihe[difficulty] > huihe { // 不是新记录不写
|
|
return
|
|
}
|
|
}
|
|
}
|
|
record.Data[boosID].Huihe[difficulty] = huihe
|
|
record.Data[boosID].Line[difficulty] = line
|
|
update["data"] = record.Data
|
|
model.Change(uid, update)
|
|
}
|
|
|
|
var (
|
|
pipe *pipe.RedisPipe = conn_.Redis.RedisPipe(context.TODO())
|
|
menbers *redis.Z
|
|
tableName string
|
|
score int32
|
|
)
|
|
score = difficulty*10000 + (10000 - huihe)
|
|
tableName = this.TableName + strconv.Itoa(int(boosID))
|
|
menbers = &redis.Z{Score: float64(score), Member: uid}
|
|
|
|
if cmd := pipe.ZAdd(tableName, menbers); cmd != nil {
|
|
if _, err = cmd.Result(); err != nil {
|
|
this.moduleViking.Errorln(err)
|
|
}
|
|
}
|
|
if _, err := pipe.Exec(); err != nil {
|
|
this.moduleViking.Errorln(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
// 获取排行榜前50的用户名单
|
|
func (this *ModelSRank) querySRankUser(bossid int) (ranks []string, err error) {
|
|
var (
|
|
result []string
|
|
conn *db.DBConn
|
|
)
|
|
conn, err = db.Cross()
|
|
if err != nil {
|
|
return
|
|
}
|
|
tableName := fmt.Sprintf("%s-%s", db.CrossTag(), this.TableName+strconv.Itoa(int(bossid)))
|
|
if result, err = conn.Redis.ZRevRange(tableName, 0, comm.MinRankList).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 *ModelSRank) raceSettlement() {
|
|
var (
|
|
result []string
|
|
Items []*pb.UserAssets
|
|
err error
|
|
szReward []*cfg.GameVikingRewardData
|
|
mailCid string
|
|
)
|
|
|
|
for iBossType := 1; iBossType <= 3; iBossType++ {
|
|
mailCid = fmt.Sprintf("SeasonViking%dReward", iBossType)
|
|
tableName := this.TableName + strconv.Itoa(int(iBossType))
|
|
szReward = this.moduleViking.configure.GetVikingRewardConf()
|
|
|
|
if result, err = this.DBModel.Redis.ZRevRange(fmt.Sprintf("%s-%s", this.DBModel, tableName), 0, comm.MaxRankList).Result(); err != nil {
|
|
this.moduleViking.Errorln(err)
|
|
return
|
|
}
|
|
|
|
if len(result) == 0 {
|
|
continue
|
|
}
|
|
szReward = this.moduleViking.configure.GetVikingRewardConf()
|
|
for _, v := range szReward {
|
|
ids := []string{} // 玩家发奖
|
|
var iEndIndex int32
|
|
if v.RankUp >= int32(len(result)) {
|
|
iEndIndex = int32(len(result))
|
|
} else {
|
|
iEndIndex = v.RankUp
|
|
}
|
|
if v.RankLow > int32(len(result)) { // 没这么多人直接返回
|
|
break
|
|
}
|
|
ids = append(result[v.RankLow-1 : iEndIndex])
|
|
|
|
this.moduleViking.mail.SendNewMail(&pb.DBMailData{ // //发邮件
|
|
Cid: mailCid,
|
|
Param: []string{fmt.Sprintf("%d-%d", v.RankLow, v.RankUp)},
|
|
CreateTime: uint64(configure.Now().Unix()),
|
|
Items: Items,
|
|
}, ids...)
|
|
}
|
|
}
|
|
|
|
ctx := context.Background()
|
|
|
|
this.DBModel.Redis.DelAllPrefixkey(ctx, fmt.Sprintf("%s-%s", this.DBModel.ServiceId, "vikingsrank"))
|
|
|
|
this.DBModel.DB.DeleteMany(core.SqlTable(this.TableName), bson.M{})
|
|
return
|
|
}
|