DNF90 服务端与启动器完整源码（含 GM 工具功能增强）

服务端（Go）： - GM 塞背包/带属性装备发放：在线角色推送 op14 增量物品行，背包实时刷新，无需回角色选择界面 - GM 改金币/改等级：去掉在线拒绝，落库后推送 op14 钱包/op37 等级状态，在线实时刷新 - 等级端点统一切换到新版 GMSetCharacterLevel（自带在线刷新） - 无限/锁死疲劳模式 + 燃烧疲劳：每房间消耗 2 点、打怪与通关经验双倍 - 燃烧疲劳开关时给所有在线角色推送系统提示（op12 mode 0） - 深渊史诗掉率：GM 全局倍率 + 城镇增益药剂窗口倍率，真实接入掉落结算启动器（Python/JS）： - 标题栏自绘、窗口 1204x717、禁止拖拽改大小、仅最小化/关闭 - GM 工具：疲劳与燃烧、深渊史诗掉率、拍卖行上架（单一定价对齐） - 拍卖行上架前端对齐服务端单一价格语义，修复 400 报错
2026-11-04 14:31:55 +08:00
commit 645b64fe21
@@ -0,0 +1,461 @@
+package statesync
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+)
+
+var (
+	ErrScopeRequired   = errors.New("state sync scope is required")
+	ErrKeyRequired     = errors.New("state sync key is required")
+	ErrRecordNotFound  = errors.New("state sync record not found")
+	ErrStaleVersion    = errors.New("state sync version is stale")
+	ErrVersionConflict = errors.New("state sync version conflicts with existing record")
+	ErrPayloadTooLarge = errors.New("state sync payload is too large")
+	ErrPayloadInvalid  = errors.New("state sync payload is invalid")
+	ErrUnsafeName      = errors.New("state sync scope or key contains unsafe character")
+	ErrStoreClosed     = errors.New("state sync store is closed")
+)
+
+type EventType string
+
+const (
+	EventUpsert EventType = "upsert"
+	EventDelete EventType = "delete"
+)
+
+type Record struct {
+	Scope     string          `json:"scope"`
+	Key       string          `json:"key"`
+	Version   int64           `json:"version"`
+	OwnerNode string          `json:"owner_node,omitempty"`
+	Payload   json.RawMessage `json:"payload,omitempty"`
+	UpdatedAt time.Time       `json:"updated_at"`
+	ExpiresAt time.Time       `json:"expires_at,omitempty"`
+	Tombstone bool            `json:"tombstone,omitempty"`
+}
+
+type Event struct {
+	Type   EventType `json:"type"`
+	Record Record    `json:"record"`
+}
+
+type Options struct {
+	MaxPayloadBytes int
+	Now             func() time.Time
+}
+
+type Store interface {
+	Upsert(context.Context, Record) (Record, error)
+	Delete(context.Context, string, string, int64) (Record, error)
+	Get(context.Context, string, string) (Record, bool, error)
+	List(context.Context, string) ([]Record, error)
+	Watch(context.Context, string, int) (<-chan Event, error)
+	SweepExpired(context.Context) (int, error)
+	Snapshot() Snapshot
+	Close() error
+}
+
+type Snapshot struct {
+	Records  int            `json:"records"`
+	Watchers map[string]int `json:"watchers,omitempty"`
+	Closed   bool           `json:"closed"`
+}
+
+type Memory struct {
+	mu              sync.RWMutex
+	records         map[string]Record
+	watchers        map[string]map[chan Event]struct{}
+	maxPayloadBytes int
+	now             func() time.Time
+	done            chan struct{}
+	closed          bool
+}
+
+func NewMemory(options Options) *Memory {
+	now := options.Now
+	if now == nil {
+		now = func() time.Time { return time.Now().UTC() }
+	}
+	return &Memory{
+		records:         make(map[string]Record),
+		watchers:        make(map[string]map[chan Event]struct{}),
+		maxPayloadBytes: options.MaxPayloadBytes,
+		now:             now,
+		done:            make(chan struct{}),
+	}
+}
+
+func (m *Memory) Upsert(ctx context.Context, record Record) (Record, error) {
+	if err := contextErr(ctx); err != nil {
+		return Record{}, err
+	}
+	if m == nil {
+		return Record{}, errors.New("state sync memory store is nil")
+	}
+	record, err := normalizeRecord(record, m.now().UTC())
+	if err != nil {
+		return Record{}, err
+	}
+	if m.maxPayloadBytes > 0 && len(record.Payload) > m.maxPayloadBytes {
+		return Record{}, fmt.Errorf("%w: %d > %d", ErrPayloadTooLarge, len(record.Payload), m.maxPayloadBytes)
+	}
+
+	m.mu.Lock()
+	if m.closed {
+		m.mu.Unlock()
+		return Record{}, ErrStoreClosed
+	}
+	key := recordKey(record.Scope, record.Key)
+	if current, ok := m.records[key]; ok {
+		switch {
+		case current.Version > record.Version:
+			m.mu.Unlock()
+			return Record{}, fmt.Errorf("%w: current=%d next=%d", ErrStaleVersion, current.Version, record.Version)
+		case current.Version == record.Version:
+			if sameRecordValue(current, record) {
+				m.mu.Unlock()
+				return cloneRecord(current), nil
+			}
+			m.mu.Unlock()
+			return Record{}, fmt.Errorf("%w: scope=%s key=%s version=%d", ErrVersionConflict, record.Scope, record.Key, record.Version)
+		}
+	}
+	m.records[key] = cloneRecord(record)
+	m.publishLocked(ctx, record.Scope, Event{Type: EventUpsert, Record: record})
+	m.mu.Unlock()
+	return cloneRecord(record), nil
+}
+
+func (m *Memory) Delete(ctx context.Context, scope, key string, version int64) (Record, error) {
+	if err := contextErr(ctx); err != nil {
+		return Record{}, err
+	}
+	if m == nil {
+		return Record{}, errors.New("state sync memory store is nil")
+	}
+	scope, key, err := normalizeScopeKey(scope, key)
+	if err != nil {
+		return Record{}, err
+	}
+	if version <= 0 {
+		version = 1
+	}
+	now := m.now().UTC()
+	deleted := Record{Scope: scope, Key: key, Version: version, UpdatedAt: now, Tombstone: true}
+
+	m.mu.Lock()
+	if m.closed {
+		m.mu.Unlock()
+		return Record{}, ErrStoreClosed
+	}
+	recordKey := recordKey(scope, key)
+	if current, ok := m.records[recordKey]; ok {
+		switch {
+		case current.Version > version:
+			m.mu.Unlock()
+			return Record{}, fmt.Errorf("%w: current=%d next=%d", ErrStaleVersion, current.Version, version)
+		case current.Version == version:
+			if current.Tombstone {
+				m.mu.Unlock()
+				return cloneRecord(current), nil
+			}
+			m.mu.Unlock()
+			return Record{}, fmt.Errorf("%w: scope=%s key=%s version=%d", ErrVersionConflict, scope, key, version)
+		}
+	}
+	m.records[recordKey] = deleted
+	m.publishLocked(ctx, scope, Event{Type: EventDelete, Record: deleted})
+	m.mu.Unlock()
+	return cloneRecord(deleted), nil
+}
+
+func (m *Memory) Get(ctx context.Context, scope, key string) (Record, bool, error) {
+	if err := contextErr(ctx); err != nil {
+		return Record{}, false, err
+	}
+	if m == nil {
+		return Record{}, false, nil
+	}
+	scope, key, err := normalizeScopeKey(scope, key)
+	if err != nil {
+		return Record{}, false, err
+	}
+	now := m.now().UTC()
+	m.mu.RLock()
+	record, ok := m.records[recordKey(scope, key)]
+	m.mu.RUnlock()
+	if !ok || isExpired(record, now) || record.Tombstone {
+		return Record{}, false, nil
+	}
+	return cloneRecord(record), true, nil
+}
+
+func (m *Memory) List(ctx context.Context, scope string) ([]Record, error) {
+	if err := contextErr(ctx); err != nil {
+		return nil, err
+	}
+	if m == nil {
+		return nil, nil
+	}
+	scope, err := normalizeScope(scope)
+	if err != nil {
+		return nil, err
+	}
+	now := m.now().UTC()
+	prefix := scope + "/"
+	var out []Record
+	m.mu.RLock()
+	for key, record := range m.records {
+		if !strings.HasPrefix(key, prefix) || record.Tombstone || isExpired(record, now) {
+			continue
+		}
+		out = append(out, cloneRecord(record))
+	}
+	m.mu.RUnlock()
+	sort.Slice(out, func(i, j int) bool { return out[i].Key < out[j].Key })
+	return out, nil
+}
+
+func (m *Memory) Watch(ctx context.Context, scope string, buffer int) (<-chan Event, error) {
+	if err := contextErr(ctx); err != nil {
+		return nil, err
+	}
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	if m == nil {
+		return nil, errors.New("state sync memory store is nil")
+	}
+	scope, err := normalizeScope(scope)
+	if err != nil {
+		return nil, err
+	}
+	if buffer < 0 {
+		buffer = 0
+	}
+	ch := make(chan Event, buffer)
+	m.mu.Lock()
+	if m.closed {
+		m.mu.Unlock()
+		close(ch)
+		return ch, nil
+	}
+	if m.watchers[scope] == nil {
+		m.watchers[scope] = make(map[chan Event]struct{})
+	}
+	m.watchers[scope][ch] = struct{}{}
+	m.mu.Unlock()
+
+	go func() {
+		select {
+		case <-ctx.Done():
+		case <-m.done:
+		}
+		m.mu.Lock()
+		if watchers := m.watchers[scope]; watchers != nil {
+			if _, ok := watchers[ch]; ok {
+				delete(watchers, ch)
+				close(ch)
+			}
+			if len(watchers) == 0 {
+				delete(m.watchers, scope)
+			}
+		}
+		m.mu.Unlock()
+	}()
+	return ch, nil
+}
+
+func (m *Memory) SweepExpired(ctx context.Context) (int, error) {
+	if err := contextErr(ctx); err != nil {
+		return 0, err
+	}
+	if m == nil {
+		return 0, nil
+	}
+	now := m.now().UTC()
+	m.mu.Lock()
+	if m.closed {
+		m.mu.Unlock()
+		return 0, ErrStoreClosed
+	}
+	removed := 0
+	for key, record := range m.records {
+		if record.Tombstone || isExpired(record, now) {
+			delete(m.records, key)
+			removed++
+		}
+	}
+	m.mu.Unlock()
+	return removed, nil
+}
+
+func (m *Memory) Snapshot() Snapshot {
+	if m == nil {
+		return Snapshot{}
+	}
+	m.mu.RLock()
+	watchers := make(map[string]int, len(m.watchers))
+	for scope, list := range m.watchers {
+		watchers[scope] = len(list)
+	}
+	snapshot := Snapshot{Records: len(m.records), Watchers: watchers, Closed: m.closed}
+	m.mu.RUnlock()
+	if len(snapshot.Watchers) == 0 {
+		snapshot.Watchers = nil
+	}
+	return snapshot
+}
+
+func (m *Memory) Close() error {
+	if m == nil {
+		return nil
+	}
+	m.mu.Lock()
+	if m.closed {
+		m.mu.Unlock()
+		return nil
+	}
+	m.closed = true
+	close(m.done)
+	for scope, watchers := range m.watchers {
+		for ch := range watchers {
+			close(ch)
+		}
+		delete(m.watchers, scope)
+	}
+	m.mu.Unlock()
+	return nil
+}
+
+// publishLocked 只做非阻塞发送，调用方必须持有 m.mu 写锁。
+// Watch/Close 也在这把锁内关闭 channel，从根源上消除 send-vs-close 竞争。
+func (m *Memory) publishLocked(ctx context.Context, scope string, event Event) {
+	if done := contextDone(ctx); done != nil {
+		select {
+		case <-done:
+			return
+		default:
+		}
+	}
+	for ch := range m.watchers[scope] {
+		select {
+		case ch <- cloneEvent(event):
+		default:
+		}
+	}
+}
+
+func normalizeRecord(record Record, now time.Time) (Record, error) {
+	scope, key, err := normalizeScopeKey(record.Scope, record.Key)
+	if err != nil {
+		return Record{}, err
+	}
+	record.Scope = scope
+	record.Key = key
+	record.OwnerNode = strings.TrimSpace(record.OwnerNode)
+	if record.Version <= 0 {
+		record.Version = 1
+	}
+	if record.UpdatedAt.IsZero() {
+		record.UpdatedAt = now.UTC()
+	} else {
+		record.UpdatedAt = record.UpdatedAt.UTC()
+	}
+	if !record.ExpiresAt.IsZero() {
+		record.ExpiresAt = record.ExpiresAt.UTC()
+	}
+	if len(record.Payload) > 0 && !json.Valid(record.Payload) {
+		return Record{}, ErrPayloadInvalid
+	}
+	record.Payload = cloneJSON(record.Payload)
+	return record, nil
+}
+
+func normalizeScopeKey(scope, key string) (string, string, error) {
+	scope, err := normalizeScope(scope)
+	if err != nil {
+		return "", "", err
+	}
+	key = strings.TrimSpace(key)
+	if key == "" {
+		return "", "", ErrKeyRequired
+	}
+	if hasUnsafeNameRune(key) {
+		return "", "", ErrUnsafeName
+	}
+	return scope, key, nil
+}
+
+func normalizeScope(scope string) (string, error) {
+	scope = strings.TrimSpace(scope)
+	if scope == "" {
+		return "", ErrScopeRequired
+	}
+	if hasUnsafeNameRune(scope) {
+		return "", ErrUnsafeName
+	}
+	return scope, nil
+}
+
+func recordKey(scope, key string) string {
+	return scope + "/" + key
+}
+
+func isExpired(record Record, now time.Time) bool {
+	return !record.ExpiresAt.IsZero() && !record.ExpiresAt.After(now)
+}
+
+func sameRecordValue(left, right Record) bool {
+	return left.OwnerNode == right.OwnerNode &&
+		left.ExpiresAt.Equal(right.ExpiresAt) &&
+		left.Tombstone == right.Tombstone &&
+		string(left.Payload) == string(right.Payload)
+}
+
+func cloneEvent(event Event) Event {
+	event.Record = cloneRecord(event.Record)
+	return event
+}
+
+func cloneRecord(record Record) Record {
+	record.Payload = cloneJSON(record.Payload)
+	return record
+}
+
+func cloneJSON(data json.RawMessage) json.RawMessage {
+	if data == nil {
+		return nil
+	}
+	return append(json.RawMessage(nil), data...)
+}
+
+func hasUnsafeNameRune(value string) bool {
+	for _, r := range value {
+		if r == '/' || r == '\\' || r == 0 || r < 0x20 || r == 0x7f {
+			return true
+		}
+	}
+	return false
+}
+
+func contextErr(ctx context.Context) error {
+	if ctx == nil {
+		return nil
+	}
+	return ctx.Err()
+}
+
+func contextDone(ctx context.Context) <-chan struct{} {
+	if ctx == nil {
+		return nil
+	}
+	return ctx.Done()
+}