《游戏服务端编程实践》9.2.2 触发条件与事件总线

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

package quest

import (
	"errors"
	"fmt"
	"strconv"
	"sync"
)

var (
	ErrEventInvalid = errors.New("bus: invalid event")
	ErrHandlerPanic = errors.New("bus: handler panicked")
)

// Event 是已经发生的事实，不是命令。Key 用于幂等去重，生产环境应由
// “类型 + 来源 + 业务序号”组合生成，不能使用随机数。
type Event struct {
	Type   string
	Source string
	Target string
	Params map[string]string
	Key    string
}

func (e Event) validate() error {
	if e.Type == "" {
		return fmt.Errorf("%w: missing type", ErrEventInvalid)
	}
	if e.Key == "" {
		return fmt.Errorf("%w: missing idempotency key", ErrEventInvalid)
	}
	return nil
}

func (e Event) amount() int {
	if raw, ok := e.Params["amount"]; ok {
		n, err := strconv.Atoi(raw)
		if err == nil && n > 0 {
			return n
		}
	}
	return 1
}

type Handler func(Event) error

type subscription struct {
	id uint64
	fn Handler
}

type PublishResult struct {
	Delivered int
	Duplicate bool
	Failed    int
	Panicked  int
}

type Bus struct {
	mu   sync.Mutex
	next uint64
	subs map[string][]subscription
	seen map[string]struct{}
}

func NewBus() *Bus {
	return &Bus{
		subs: make(map[string][]subscription),
		seen: make(map[string]struct{}),
	}
}

// Subscribe 按注册顺序回调，返回的函数用于退订。回调在发布线程同步执行。
func (b *Bus) Subscribe(eventType string, fn Handler) func() {
	if fn == nil {
		return func() {}
	}
	b.mu.Lock()
	b.next++
	id := b.next
	b.subs[eventType] = append(b.subs[eventType], subscription{id: id, fn: fn})
	b.mu.Unlock()
	return func() { b.unsubscribe(eventType, id) }
}

func (b *Bus) unsubscribe(eventType string, id uint64) {
	b.mu.Lock()
	defer b.mu.Unlock()
	list := b.subs[eventType]
	for i, s := range list {
		if s.id == id {
			b.subs[eventType] = append(list[:i], list[i+1:]...)
			return
		}
	}
}

// Publish 对相同 Key 只分发一次；单个订阅者失败或 panic 不影响其后的订阅者。
func (b *Bus) Publish(ev Event) (PublishResult, error) {
	if err := ev.validate(); err != nil {
		return PublishResult{}, err
	}
	b.mu.Lock()
	if _, ok := b.seen[ev.Key]; ok {
		b.mu.Unlock()
		return PublishResult{Duplicate: true}, nil
	}
	b.seen[ev.Key] = struct{}{}
	handlers := append([]subscription(nil), b.subs[ev.Type]...)
	b.mu.Unlock()

	var res PublishResult
	var errs []error
	for _, s := range handlers {
		func() {
			defer func() {
				if r := recover(); r != nil {
					res.Panicked++
					errs = append(errs, fmt.Errorf("%w: %v", ErrHandlerPanic, r))
				}
			}()
			if err := s.fn(ev); err != nil {
				res.Failed++
				errs = append(errs, err)
				return
			}
			res.Delivered++
		}()
	}
	return res, errors.Join(errs...)
}

// QuestListener 把战斗、采集、到达事件翻译成任务进度；任务只是订阅者之一。
func QuestListener(log *QuestLog) Handler {
	return func(ev Event) error {
		kind, ok := objectiveKind(ev.Type)
		if !ok {
			return nil
		}
		log.Advance(kind, ev.Target, ev.amount())
		return nil
	}
}

func objectiveKind(eventType string) (ObjectiveKind, bool) {
	switch eventType {
	case "kill":
		return KindKill, true
	case "collect":
		return KindCollect, true
	case "reach":
		return KindReach, true
	case "count":
		return KindCount, true
	default:
		return 0, false
	}
}

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