《游戏服务端编程实践》9.2.1 任务状态机

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

package quest

import (
	"errors"
	"fmt"
	"sort"
	"sync"
)

var (
	ErrUnknownQuest = errors.New("quest: unknown quest")
	ErrPrereq       = errors.New("quest: prerequisite not completed")
	ErrInvalidState = errors.New("quest: invalid state for operation")
	ErrExclusive    = errors.New("quest: conflicts with an active quest")
	ErrAlreadyDone  = errors.New("quest: already completed")
)

// QuestState 描述任务在玩家日志中的位置；布尔值无法表达“可交付”。
type QuestState int

const (
	StateAvailable QuestState = iota // 未接
	StateActive                      // 进行中
	StateReady                       // 目标完成，等待交付
	StateCompleted                   // 已交付
	StateFailed                      // 失败或放弃
)

type ObjectiveKind int

const (
	KindCount ObjectiveKind = iota
	KindCollect
	KindReach
	KindKill
)

type Objective struct {
	Kind     ObjectiveKind
	Target   string
	Required int
	Current  int
}

type QuestDef struct {
	ID         string
	Prereqs    []string
	Exclusive  []string
	Objectives []Objective
	RewardGold int
}

type QuestEntry struct {
	Objectives []Objective
	RewardGold int
	State      QuestState
}

type ProgressUpdate struct {
	QuestID   string
	Objective int
	Current   int
	Required  int
}

type QuestLog struct {
	mu      sync.Mutex
	defs    map[string]QuestDef
	entries map[string]*QuestEntry
	gold    int
}

func NewQuestLog(defs []QuestDef) (*QuestLog, error) {
	l := &QuestLog{
		defs:    make(map[string]QuestDef, len(defs)),
		entries: make(map[string]*QuestEntry),
	}
	for _, d := range defs {
		if d.ID == "" {
			return nil, fmt.Errorf("%w: empty id", ErrUnknownQuest)
		}
		if _, ok := l.defs[d.ID]; ok {
			return nil, fmt.Errorf("quest: duplicate definition %q", d.ID)
		}
		l.defs[d.ID] = cloneDef(d)
	}
	for id, d := range l.defs {
		for _, other := range d.Exclusive {
			if o, ok := l.defs[other]; ok && other != id {
				o.Exclusive = append(o.Exclusive, id)
				l.defs[other] = o
			}
		}
	}
	return l, nil
}

// Accept 只创建进行中的条目，前置与互斥都在锁内检查。
func (l *QuestLog) Accept(id string) error {
	l.mu.Lock()
	defer l.mu.Unlock()
	def, ok := l.defs[id]
	if !ok {
		return ErrUnknownQuest
	}
	if e := l.entries[id]; e != nil {
		if e.State == StateCompleted {
			return ErrAlreadyDone
		}
		if e.State == StateActive || e.State == StateReady {
			return ErrInvalidState
		}
	}
	for _, p := range def.Prereqs {
		if e := l.entries[p]; e == nil || e.State != StateCompleted {
			return fmt.Errorf("%w: %s", ErrPrereq, p)
		}
	}
	for _, other := range def.Exclusive {
		if e := l.entries[other]; e != nil && (e.State == StateActive || e.State == StateReady) {
			return fmt.Errorf("%w: %s", ErrExclusive, other)
		}
	}
	l.entries[id] = &QuestEntry{
		Objectives: append([]Objective(nil), def.Objectives...),
		RewardGold: def.RewardGold,
		State:      StateActive,
	}
	return nil
}

// Advance 用一次事件推进所有匹配的进行中任务。
func (l *QuestLog) Advance(kind ObjectiveKind, target string, amount int) []ProgressUpdate {
	if amount <= 0 {
		return nil
	}
	l.mu.Lock()
	defer l.mu.Unlock()
	ids := make([]string, 0, len(l.entries))
	for id := range l.entries {
		ids = append(ids, id)
	}
	sort.Strings(ids)
	var out []ProgressUpdate
	for _, id := range ids {
		e := l.entries[id]
		if e.State != StateActive && e.State != StateReady {
			continue
		}
		for i := range e.Objectives {
			o := &e.Objectives[i]
			if o.Kind != kind || o.Target != target || o.Current >= o.Required {
				continue
			}
			o.Current += amount
			if o.Current > o.Required {
				o.Current = o.Required
			}
			out = append(out, ProgressUpdate{QuestID: id, Objective: i, Current: o.Current, Required: o.Required})
		}
		if e.ready() {
			e.State = StateReady
		}
	}
	return out
}

// TurnIn 在同一临界区完成状态变更与奖励发放，重复交付在发奖前被拒绝。
func (l *QuestLog) TurnIn(id string) (int, error) {
	l.mu.Lock()
	defer l.mu.Unlock()
	e := l.entries[id]
	if e == nil {
		return 0, ErrUnknownQuest
	}
	if e.State == StateCompleted {
		return 0, ErrAlreadyDone
	}
	if e.State != StateReady {
		return 0, ErrInvalidState
	}
	e.State = StateCompleted
	l.gold += e.RewardGold
	return e.RewardGold, nil
}

// Abandon 退回失败态并清零进度，避免重新接取时继承旧计数。
func (l *QuestLog) Abandon(id string) error {
	l.mu.Lock()
	defer l.mu.Unlock()
	e := l.entries[id]
	if e == nil {
		return ErrUnknownQuest
	}
	if e.State == StateCompleted {
		return ErrInvalidState
	}
	e.State = StateFailed
	e.Objectives = append([]Objective(nil), l.defs[id].Objectives...)
	return nil
}

func (l *QuestLog) State(id string) (QuestState, bool) {
	l.mu.Lock()
	defer l.mu.Unlock()
	e := l.entries[id]
	if e == nil {
		return StateAvailable, false
	}
	return e.State, true
}

func (l *QuestLog) Gold() int {
	l.mu.Lock()
	defer l.mu.Unlock()
	return l.gold
}

func (e *QuestEntry) ready() bool {
	for _, o := range e.Objectives {
		if o.Current < o.Required {
			return false
		}
	}
	return true
}

func cloneDef(d QuestDef) QuestDef {
	d.Objectives = append([]Objective(nil), d.Objectives...)
	d.Prereqs = append([]string(nil), d.Prereqs...)
	d.Exclusive = append([]string(nil), d.Exclusive...)
	return d
}

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