361 lines
9.4 KiB
Go
361 lines
9.4 KiB
Go
package service
|
|
|
|
import (
|
|
"blazing/common/data"
|
|
"blazing/cool"
|
|
configmodel "blazing/modules/config/model"
|
|
configservice "blazing/modules/config/service"
|
|
"blazing/modules/player/model"
|
|
"fmt"
|
|
"sort"
|
|
"time"
|
|
)
|
|
|
|
const signRecordID uint32 = 1
|
|
|
|
// SignStageState 表示一个签到阶段的当前状态。
|
|
type SignStageState struct {
|
|
SignType uint32 `json:"sign_type"`
|
|
StageDays uint32 `json:"stage_days"`
|
|
CdkID uint32 `json:"cdk_id"`
|
|
Reached bool `json:"reached"`
|
|
Claimed bool `json:"claimed"`
|
|
}
|
|
|
|
// SignState 表示玩家当前签到进度和阶段状态。
|
|
type SignState struct {
|
|
TotalDays uint32 `json:"total_days"`
|
|
ContinuousDays uint32 `json:"continuous_days"`
|
|
LastSignDate string `json:"last_sign_date"`
|
|
TodaySigned bool `json:"today_signed"`
|
|
Stages []SignStageState `json:"stages"`
|
|
}
|
|
|
|
// SignRewardResult 表示一次签到后自动发放的阶段奖励。
|
|
type SignRewardResult struct {
|
|
SignType uint32 `json:"sign_type"`
|
|
StageDays uint32 `json:"stage_days"`
|
|
CdkID uint32 `json:"cdk_id"`
|
|
Items []data.ItemInfo `json:"items,omitempty"`
|
|
PetIDs []uint32 `json:"pet_ids,omitempty"`
|
|
TitleIDs []uint32 `json:"title_ids,omitempty"`
|
|
Coins int64 `json:"coins,omitempty"`
|
|
Gold int64 `json:"gold,omitempty"`
|
|
FreeGold int64 `json:"free_gold,omitempty"`
|
|
ExpPool int64 `json:"exp_pool,omitempty"`
|
|
EVPool int64 `json:"ev_pool,omitempty"`
|
|
}
|
|
|
|
// SignClaimResult 表示签到后的完整结果。
|
|
type SignClaimResult struct {
|
|
State *SignState `json:"state"`
|
|
Rewards []SignRewardResult `json:"rewards,omitempty"`
|
|
}
|
|
|
|
// SignResetResult 表示管理端执行的签到重置结果。
|
|
type SignResetResult struct {
|
|
SignRecordRows int64 `json:"sign_record_rows"`
|
|
CdkLogRows int64 `json:"cdk_log_rows"`
|
|
ResetCdkIDs []uint32 `json:"reset_cdk_ids"`
|
|
}
|
|
|
|
// SignService 管理玩家签到进度。
|
|
type SignService struct {
|
|
BaseService
|
|
}
|
|
|
|
func NewSignService(id uint32) *SignService {
|
|
return &SignService{
|
|
BaseService: BaseService{
|
|
userid: id,
|
|
Service: &cool.Service{
|
|
Model: model.NewSignInRecord(),
|
|
ListQueryOp: &cool.QueryOp{
|
|
FieldEQ: []string{"player_id", "is_completed"},
|
|
},
|
|
PageQueryOp: &cool.QueryOp{
|
|
FieldEQ: []string{"player_id", "is_completed"},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func (s *SignService) GetState() (*SignState, error) {
|
|
record, err := s.getRecord()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return s.buildState(record), nil
|
|
}
|
|
|
|
func (s *SignService) Claim() (*SignClaimResult, error) {
|
|
record, isNew, err := s.getOrInitRecord()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
today := currentDateString()
|
|
if record.LastSignDate == today {
|
|
return nil, fmt.Errorf("今天已经签到过了")
|
|
}
|
|
|
|
prevTotalDays := record.TotalDays
|
|
prevContinuousDays := record.ContinuousDays
|
|
prevDate := record.LastSignDate
|
|
record.LastSignDate = today
|
|
record.TotalDays++
|
|
if isYesterday(prevDate, today) {
|
|
record.ContinuousDays++
|
|
} else {
|
|
record.ContinuousDays = 1
|
|
}
|
|
|
|
rewards, err := s.grantReachedStageRewards(record, prevTotalDays, prevContinuousDays)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := s.saveRecord(record, isNew); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &SignClaimResult{
|
|
State: s.buildState(record),
|
|
Rewards: rewards,
|
|
}, nil
|
|
}
|
|
|
|
func (s *SignService) ResetAll() (*SignResetResult, error) {
|
|
result := &SignResetResult{}
|
|
|
|
signRes, err := cool.DBM(model.NewSignInRecord()).Delete()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if signRes != nil {
|
|
result.SignRecordRows, _ = signRes.RowsAffected()
|
|
}
|
|
|
|
configs := configservice.NewSignInService().GetEnabled()
|
|
cdkIDs := make([]uint32, 0, len(configs))
|
|
seen := make(map[uint32]struct{}, len(configs))
|
|
for _, cfg := range configs {
|
|
if cfg.CdkID == 0 {
|
|
continue
|
|
}
|
|
if _, ok := seen[cfg.CdkID]; ok {
|
|
continue
|
|
}
|
|
seen[cfg.CdkID] = struct{}{}
|
|
cdkIDs = append(cdkIDs, cfg.CdkID)
|
|
}
|
|
sort.Slice(cdkIDs, func(i, j int) bool { return cdkIDs[i] < cdkIDs[j] })
|
|
result.ResetCdkIDs = cdkIDs
|
|
|
|
if len(cdkIDs) > 0 {
|
|
cdkRes, err := cool.DBM(model.NewCdkLog()).WhereIn("code_id", cdkIDs).Delete()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if cdkRes != nil {
|
|
result.CdkLogRows, _ = cdkRes.RowsAffected()
|
|
}
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func (s *SignService) grantReachedStageRewards(record *model.SignInRecord, prevTotalDays, prevContinuousDays uint32) ([]SignRewardResult, error) {
|
|
configs := configservice.NewSignInService().GetEnabled()
|
|
if len(configs) == 0 {
|
|
return nil, nil
|
|
}
|
|
|
|
baseRewardBySignType := make(map[uint32]configmodel.SignIn)
|
|
for _, cfg := range configs {
|
|
if cfg.StageDays == 0 {
|
|
baseRewardBySignType[cfg.SignType] = cfg
|
|
}
|
|
}
|
|
|
|
cdkLogService := NewCdkService(s.userid)
|
|
results := make([]SignRewardResult, 0)
|
|
for _, cfg := range configs {
|
|
if cfg.StageDays == 0 {
|
|
continue
|
|
}
|
|
if !stageReached(cfg.SignType, cfg.StageDays, record) {
|
|
continue
|
|
}
|
|
if stageReachedByDays(cfg.SignType, cfg.StageDays, prevTotalDays, prevContinuousDays) {
|
|
continue
|
|
}
|
|
|
|
rewardCdkID := cfg.CdkID
|
|
if !cdkLogService.CanGet(cfg.CdkID) {
|
|
baseCfg, ok := baseRewardBySignType[cfg.SignType]
|
|
if !ok || !cdkLogService.CanGet(baseCfg.CdkID) {
|
|
continue
|
|
}
|
|
rewardCdkID = baseCfg.CdkID
|
|
}
|
|
|
|
reward, err := cdkLogService.GrantConfigReward(rewardCdkID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
results = append(results, buildSignRewardResult(cfg.SignType, cfg.StageDays, reward))
|
|
cdkLogService.Log(rewardCdkID)
|
|
}
|
|
|
|
sort.Slice(results, func(i, j int) bool {
|
|
if results[i].SignType != results[j].SignType {
|
|
return results[i].SignType < results[j].SignType
|
|
}
|
|
if results[i].StageDays != results[j].StageDays {
|
|
return results[i].StageDays < results[j].StageDays
|
|
}
|
|
return results[i].CdkID < results[j].CdkID
|
|
})
|
|
return results, nil
|
|
}
|
|
|
|
func buildSignRewardResult(signType, stageDays uint32, reward *CdkRewardResult) SignRewardResult {
|
|
result := SignRewardResult{
|
|
SignType: signType,
|
|
StageDays: stageDays,
|
|
CdkID: reward.CdkID,
|
|
Items: reward.Items,
|
|
TitleIDs: reward.TitleIDs,
|
|
Coins: reward.Coins,
|
|
Gold: reward.Gold,
|
|
FreeGold: reward.FreeGold,
|
|
ExpPool: reward.ExpPool,
|
|
EVPool: reward.EVPool,
|
|
}
|
|
if len(reward.Pets) > 0 {
|
|
result.PetIDs = make([]uint32, 0, len(reward.Pets))
|
|
for _, pet := range reward.Pets {
|
|
result.PetIDs = append(result.PetIDs, pet.PetID)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
func (s *SignService) buildState(record *model.SignInRecord) *SignState {
|
|
state := &SignState{
|
|
Stages: make([]SignStageState, 0),
|
|
}
|
|
if record != nil {
|
|
state.TotalDays = record.TotalDays
|
|
state.ContinuousDays = record.ContinuousDays
|
|
state.LastSignDate = record.LastSignDate
|
|
state.TodaySigned = record.LastSignDate == currentDateString()
|
|
}
|
|
|
|
cdkLogService := NewCdkService(s.userid)
|
|
configs := configservice.NewSignInService().GetEnabled()
|
|
for _, cfg := range configs {
|
|
if cfg.StageDays == 0 {
|
|
continue
|
|
}
|
|
state.Stages = append(state.Stages, SignStageState{
|
|
SignType: cfg.SignType,
|
|
StageDays: cfg.StageDays,
|
|
CdkID: cfg.CdkID,
|
|
Reached: stageReached(cfg.SignType, cfg.StageDays, record),
|
|
Claimed: !cdkLogService.CanGet(cfg.CdkID),
|
|
})
|
|
}
|
|
return state
|
|
}
|
|
|
|
func stageReached(signType, stageDays uint32, record *model.SignInRecord) bool {
|
|
if record == nil {
|
|
return false
|
|
}
|
|
return stageReachedByDays(signType, stageDays, record.TotalDays, record.ContinuousDays)
|
|
}
|
|
|
|
func stageReachedByDays(signType, stageDays, totalDays, continuousDays uint32) bool {
|
|
if stageDays == 0 {
|
|
return false
|
|
}
|
|
switch signType {
|
|
case configmodel.SignTypeContinuous:
|
|
return continuousDays >= stageDays
|
|
default:
|
|
return totalDays >= stageDays
|
|
}
|
|
}
|
|
|
|
func (s *SignService) getRecord() (*model.SignInRecord, error) {
|
|
var out *model.SignInRecord
|
|
if err := s.dbm(s.Model).Where("sign_in_id", signRecordID).Scan(&out); err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (s *SignService) getOrInitRecord() (*model.SignInRecord, bool, error) {
|
|
record, err := s.getRecord()
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
if record != nil {
|
|
return record, false, nil
|
|
}
|
|
|
|
return &model.SignInRecord{
|
|
Base: model.Base{
|
|
Model: cool.NewModel(),
|
|
IsVip: cool.Config.ServerInfo.IsVip,
|
|
},
|
|
PlayerID: s.userid,
|
|
SignInID: signRecordID,
|
|
IsCompleted: false,
|
|
ContinuousDays: 0,
|
|
TotalDays: 0,
|
|
LastSignDate: "",
|
|
SignInProgress: []uint32{},
|
|
}, true, nil
|
|
}
|
|
|
|
func (s *SignService) saveRecord(record *model.SignInRecord, isNew bool) error {
|
|
data := map[string]any{
|
|
"player_id": record.PlayerID,
|
|
"sign_in_id": record.SignInID,
|
|
"is_completed": false,
|
|
"continuous_days": record.ContinuousDays,
|
|
"total_days": record.TotalDays,
|
|
"last_sign_date": record.LastSignDate,
|
|
"sign_in_progress": []uint32{},
|
|
"is_vip": cool.Config.ServerInfo.IsVip,
|
|
}
|
|
if isNew {
|
|
_, err := cool.DBM(s.Model).Data(data).Insert()
|
|
return err
|
|
}
|
|
_, err := s.dbm(s.Model).Where("sign_in_id", signRecordID).Data(data).Update()
|
|
return err
|
|
}
|
|
|
|
func currentDateString() string {
|
|
return time.Now().Format("2006-01-02")
|
|
}
|
|
|
|
func isYesterday(previousDate, currentDate string) bool {
|
|
if previousDate == "" || currentDate == "" {
|
|
return false
|
|
}
|
|
prev, err := time.ParseInLocation("2006-01-02", previousDate, time.Local)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
curr, err := time.ParseInLocation("2006-01-02", currentDate, time.Local)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
return prev.Add(24 * time.Hour).Equal(curr)
|
|
}
|