《游戏服务端编程实践》9.2.3 日常任务与成就系统

// file: ch09/quest/daily.go
// tier: L1
// verify: go test ./ch09/quest/

package quest

import (
	"errors"
	"fmt"
	"sync"
	"time"
)

var (
	ErrAchievementUnknown  = errors.New("achievement: unknown achievement")
	ErrAchievementNotReady = errors.New("achievement: not complete")
	ErrAchievementClaimed  = errors.New("achievement: reward already claimed")
)

type Period int

const (
	Daily Period = iota
	Weekly
)

// Key 把时间点映射为周期键。所有计算都先换到 loc，再截断日期或取 ISO 周。
func (p Period) Key(now time.Time, loc *time.Location) string {
	t := now.In(loc)
	if p == Weekly {
		year, week := t.ISOWeek()
		return fmt.Sprintf("%04d-W%02d", year, week)
	}
	return t.Format("2006-01-02")
}

type ResetRecord struct {
	Key      string
	At       time.Time
	Counters map[string]int
}

type DailyReset struct {
	mu       sync.Mutex
	loc      *time.Location
	period   Period
	counters map[string]int
	lastKey  string
	history  []ResetRecord
}

func NewDailyReset(loc *time.Location, period Period) *DailyReset {
	if loc == nil {
		loc = time.UTC
	}
	return &DailyReset{
		loc:      loc,
		period:   period,
		counters: make(map[string]int),
	}
}

func (d *DailyReset) Add(id string, n int) int {
	d.mu.Lock()
	defer d.mu.Unlock()
	if n > 0 {
		d.counters[id] += n
	}
	return d.counters[id]
}

// AddAt 先按当前时刻滚动周期，再累加，用于“跨天仍在线上”的玩家。
func (d *DailyReset) AddAt(now time.Time, id string, n int) (int, bool) {
	d.mu.Lock()
	defer d.mu.Unlock()
	_, reset := d.rollLocked(now)
	if n > 0 {
		d.counters[id] += n
	}
	return d.counters[id], reset
}

func (d *DailyReset) ResetNow(now time.Time) (ResetRecord, bool) {
	d.mu.Lock()
	defer d.mu.Unlock()
	return d.rollLocked(now)
}

// rollLocked 只在周期键变化时归档并清零，因此重复调用是幂等的。
func (d *DailyReset) rollLocked(now time.Time) (ResetRecord, bool) {
	key := d.period.Key(now, d.loc)
	if key == d.lastKey {
		return ResetRecord{}, false
	}
	rec := ResetRecord{Key: key, At: now, Counters: make(map[string]int, len(d.counters))}
	for id, n := range d.counters {
		rec.Counters[id] = n
	}
	d.history = append(d.history, rec)
	d.counters = make(map[string]int)
	d.lastKey = key
	return rec, true
}

func (d *DailyReset) Count(id string) int {
	d.mu.Lock()
	defer d.mu.Unlock()
	return d.counters[id]
}

func (d *DailyReset) PeriodKey(now time.Time) string {
	return d.period.Key(now, d.loc)
}

// History 返回深拷贝，调用方修改记录不会影响内部状态。
func (d *DailyReset) History() []ResetRecord {
	d.mu.Lock()
	defer d.mu.Unlock()
	out := make([]ResetRecord, len(d.history))
	for i, rec := range d.history {
		out[i] = rec
		out[i].Counters = make(map[string]int, len(rec.Counters))
		for id, n := range rec.Counters {
			out[i].Counters[id] = n
		}
	}
	return out
}

type Achievement struct {
	ID       string
	Target   int
	Hidden   bool
	Progress int
	Claimed  bool
}

// AchievementLedger 只记录累计进度与领取状态，奖励内容由调用方按 ID 发放。
type AchievementLedger struct {
	mu    sync.Mutex
	items map[string]*Achievement
}

func NewAchievementLedger() *AchievementLedger {
	return &AchievementLedger{items: make(map[string]*Achievement)}
}

func (a *AchievementLedger) Add(id string, target int, hidden bool, n int) Achievement {
	a.mu.Lock()
	defer a.mu.Unlock()
	it := a.items[id]
	if it == nil {
		it = &Achievement{ID: id, Target: target, Hidden: hidden}
		a.items[id] = it
	}
	if target > 0 {
		it.Target = target
	}
	if n > 0 && it.Progress < it.Target {
		it.Progress += n
		if it.Progress > it.Target {
			it.Progress = it.Target
		}
	}
	return *it
}

func (a *AchievementLedger) Claim(id string) (Achievement, error) {
	a.mu.Lock()
	defer a.mu.Unlock()
	it := a.items[id]
	if it == nil {
		return Achievement{}, ErrAchievementUnknown
	}
	if it.Claimed {
		return *it, ErrAchievementClaimed
	}
	if it.Progress < it.Target {
		return *it, ErrAchievementNotReady
	}
	it.Claimed = true
	return *it, nil
}

func (a *AchievementLedger) Get(id string) (Achievement, bool) {
	a.mu.Lock()
	defer a.mu.Unlock()
	it := a.items[id]
	if it == nil {
		return Achievement{}, false
	}
	return *it, true
}

cd .local/checks/gs-practice-lab
gofmt -l ch09/quest
go vet ./ch09/quest/
go test ./ch09/quest/ -count=1

ok  	gspractice/ch09/quest	0.475s