hanfuit
645b64fe21
服务端（Go）： - GM 塞背包/带属性装备发放：在线角色推送 op14 增量物品行，背包实时刷新，无需回角色选择界面 - GM 改金币/改等级：去掉在线拒绝，落库后推送 op14 钱包/op37 等级状态，在线实时刷新 - 等级端点统一切换到新版 GMSetCharacterLevel（自带在线刷新） - 无限/锁死疲劳模式 + 燃烧疲劳：每房间消耗 2 点、打怪与通关经验双倍 - 燃烧疲劳开关时给所有在线角色推送系统提示（op12 mode 0） - 深渊史诗掉率：GM 全局倍率 + 城镇增益药剂窗口倍率，真实接入掉落结算 启动器（Python/JS）： - 标题栏自绘、窗口 1204x717、禁止拖拽改大小、仅最小化/关闭 - GM 工具：疲劳与燃烧、深渊史诗掉率、拍卖行上架（单一定价对齐） - 拍卖行上架前端对齐服务端单一价格语义，修复 400 报错
385 lines
8.5 KiB
Go
385 lines
8.5 KiB
Go
package datatable
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/fs"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
var (
|
|
ErrDirectoryRequired = errors.New("data table directory is required")
|
|
ErrRegistryRequired = errors.New("data table registry is required")
|
|
ErrTableRequired = errors.New("data table name is required")
|
|
ErrTableNotFound = errors.New("data table not found")
|
|
)
|
|
|
|
type Table struct {
|
|
Name string `json:"name"`
|
|
Path string `json:"path"`
|
|
Version string `json:"version"`
|
|
Checksum string `json:"checksum"`
|
|
Rows int `json:"rows"`
|
|
Bytes int64 `json:"bytes"`
|
|
LoadedAt time.Time `json:"loaded_at"`
|
|
}
|
|
|
|
type Registry struct {
|
|
root string
|
|
version string
|
|
|
|
mu sync.RWMutex
|
|
tables map[string]Table
|
|
raw map[string][]byte
|
|
manifest Manifest
|
|
watchers map[chan LoadResult]struct{}
|
|
}
|
|
|
|
func NewRegistry(root, version string) *Registry {
|
|
root = strings.TrimSpace(root)
|
|
version = strings.TrimSpace(version)
|
|
return &Registry{
|
|
root: root,
|
|
version: version,
|
|
tables: make(map[string]Table),
|
|
raw: make(map[string][]byte),
|
|
manifest: Manifest{Root: root, Version: version},
|
|
watchers: make(map[chan LoadResult]struct{}),
|
|
}
|
|
}
|
|
|
|
func (r *Registry) Load(ctx context.Context) error {
|
|
if r == nil {
|
|
return nil
|
|
}
|
|
if ctx == nil {
|
|
ctx = context.Background()
|
|
}
|
|
r.mu.RLock()
|
|
root := strings.TrimSpace(r.root)
|
|
version := r.version
|
|
r.mu.RUnlock()
|
|
_, err := r.ReloadDir(ctx, root, version, ReloadOptions{})
|
|
return err
|
|
}
|
|
|
|
func (r *Registry) LoadDir(ctx context.Context, root, version string) error {
|
|
_, err := r.ReloadDir(ctx, root, version, ReloadOptions{})
|
|
return err
|
|
}
|
|
|
|
func (r *Registry) Reload(ctx context.Context, options ReloadOptions) (LoadResult, error) {
|
|
if r == nil {
|
|
return LoadResult{}, nil
|
|
}
|
|
if ctx == nil {
|
|
ctx = context.Background()
|
|
}
|
|
r.mu.RLock()
|
|
root := strings.TrimSpace(r.root)
|
|
version := r.version
|
|
r.mu.RUnlock()
|
|
return r.ReloadDir(ctx, root, version, options)
|
|
}
|
|
|
|
func (r *Registry) ReloadDir(ctx context.Context, root, version string, options ReloadOptions) (LoadResult, error) {
|
|
if r == nil {
|
|
return LoadResult{}, nil
|
|
}
|
|
if ctx == nil {
|
|
ctx = context.Background()
|
|
}
|
|
dataset, err := loadDirectory(ctx, root, version)
|
|
if err != nil {
|
|
return LoadResult{}, err
|
|
}
|
|
if err := options.validate(ctx, dataset); err != nil {
|
|
return LoadResult{}, err
|
|
}
|
|
|
|
r.mu.Lock()
|
|
diff := diffTables(r.tables, dataset.tables)
|
|
result := LoadResult{
|
|
Manifest: dataset.manifest,
|
|
Diff: diff,
|
|
LoadedAt: dataset.manifest.LoadedAt,
|
|
}
|
|
r.root = dataset.root
|
|
r.version = dataset.version
|
|
r.tables = cloneTableMap(dataset.tables)
|
|
r.raw = cloneRawMap(dataset.raw)
|
|
r.manifest = dataset.manifest
|
|
for ch := range r.watchers {
|
|
select {
|
|
case ch <- cloneLoadResult(result):
|
|
default:
|
|
}
|
|
}
|
|
r.mu.Unlock()
|
|
return cloneLoadResult(result), nil
|
|
}
|
|
|
|
func (r *Registry) Configure(root, version string) {
|
|
if r == nil {
|
|
return
|
|
}
|
|
r.mu.Lock()
|
|
r.root = strings.TrimSpace(root)
|
|
r.version = strings.TrimSpace(version)
|
|
if len(r.tables) == 0 {
|
|
r.manifest = Manifest{Root: r.root, Version: r.version}
|
|
}
|
|
r.mu.Unlock()
|
|
}
|
|
|
|
func (r *Registry) Clear() {
|
|
if r == nil {
|
|
return
|
|
}
|
|
r.mu.Lock()
|
|
r.tables = make(map[string]Table)
|
|
r.raw = make(map[string][]byte)
|
|
r.manifest = Manifest{Root: r.root, Version: r.version}
|
|
r.mu.Unlock()
|
|
}
|
|
|
|
func (r *Registry) Snapshot() []Table {
|
|
if r == nil {
|
|
return nil
|
|
}
|
|
r.mu.RLock()
|
|
out := make([]Table, 0, len(r.tables))
|
|
for _, table := range r.tables {
|
|
out = append(out, table)
|
|
}
|
|
r.mu.RUnlock()
|
|
sort.Slice(out, func(i, j int) bool { return out[i].Name < out[j].Name })
|
|
return out
|
|
}
|
|
|
|
func (r *Registry) Manifest() Manifest {
|
|
if r == nil {
|
|
return Manifest{}
|
|
}
|
|
r.mu.RLock()
|
|
manifest := r.manifest
|
|
r.mu.RUnlock()
|
|
return manifest
|
|
}
|
|
|
|
func (r *Registry) Decode(name string, out any) error {
|
|
if r == nil {
|
|
return ErrTableNotFound
|
|
}
|
|
name = strings.TrimSpace(name)
|
|
if name == "" {
|
|
return ErrTableRequired
|
|
}
|
|
if out == nil {
|
|
return fmt.Errorf("decode target for data table %q is nil", name)
|
|
}
|
|
r.mu.RLock()
|
|
data, ok := r.raw[name]
|
|
data = append([]byte(nil), data...)
|
|
r.mu.RUnlock()
|
|
if !ok {
|
|
return fmt.Errorf("%w: %s", ErrTableNotFound, name)
|
|
}
|
|
if err := json.Unmarshal(data, out); err != nil {
|
|
return fmt.Errorf("decode data table %q: %w", name, err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *Registry) Get(name string) (Table, bool) {
|
|
if r == nil {
|
|
return Table{}, false
|
|
}
|
|
name = strings.TrimSpace(name)
|
|
r.mu.RLock()
|
|
table, ok := r.tables[name]
|
|
r.mu.RUnlock()
|
|
return table, ok
|
|
}
|
|
|
|
func (r *Registry) Root() string {
|
|
if r == nil {
|
|
return ""
|
|
}
|
|
r.mu.RLock()
|
|
root := r.root
|
|
r.mu.RUnlock()
|
|
return root
|
|
}
|
|
|
|
func (r *Registry) Version() string {
|
|
if r == nil {
|
|
return ""
|
|
}
|
|
r.mu.RLock()
|
|
version := r.version
|
|
r.mu.RUnlock()
|
|
return version
|
|
}
|
|
|
|
func (r *Registry) Watch(ctx context.Context, buffer int) (<-chan LoadResult, error) {
|
|
if ctxErr := contextErr(ctx); ctxErr != nil {
|
|
return nil, ctxErr
|
|
}
|
|
if ctx == nil {
|
|
ctx = context.Background()
|
|
}
|
|
if r == nil {
|
|
return nil, ErrRegistryRequired
|
|
}
|
|
if buffer < 0 {
|
|
buffer = 0
|
|
}
|
|
ch := make(chan LoadResult, buffer)
|
|
r.mu.Lock()
|
|
if r.watchers == nil {
|
|
r.watchers = make(map[chan LoadResult]struct{})
|
|
}
|
|
r.watchers[ch] = struct{}{}
|
|
r.mu.Unlock()
|
|
go func() {
|
|
<-ctx.Done()
|
|
r.mu.Lock()
|
|
if _, ok := r.watchers[ch]; ok {
|
|
delete(r.watchers, ch)
|
|
close(ch)
|
|
}
|
|
r.mu.Unlock()
|
|
}()
|
|
return ch, nil
|
|
}
|
|
|
|
func loadDirectory(ctx context.Context, root, version string) (Dataset, error) {
|
|
if ctx == nil {
|
|
ctx = context.Background()
|
|
}
|
|
root = strings.TrimSpace(root)
|
|
version = strings.TrimSpace(version)
|
|
if root == "" {
|
|
return Dataset{}, ErrDirectoryRequired
|
|
}
|
|
info, err := os.Stat(root)
|
|
if err != nil {
|
|
return Dataset{}, fmt.Errorf("stat data table directory %q: %w", root, err)
|
|
}
|
|
if !info.IsDir() {
|
|
return Dataset{}, fmt.Errorf("data table directory %q is not a directory", root)
|
|
}
|
|
|
|
loadedAt := time.Now().UTC()
|
|
tables := make(map[string]Table)
|
|
raw := make(map[string][]byte)
|
|
if err := filepath.WalkDir(root, func(path string, entry fs.DirEntry, err error) error {
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if ctxErr := ctx.Err(); ctxErr != nil {
|
|
return ctxErr
|
|
}
|
|
if entry.IsDir() {
|
|
return nil
|
|
}
|
|
if !isJSONTable(entry.Name()) {
|
|
return nil
|
|
}
|
|
table, data, err := loadOne(root, version, path, loadedAt)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if existing, ok := tables[table.Name]; ok {
|
|
return fmt.Errorf("duplicate data table name %q from %q and %q", table.Name, existing.Path, table.Path)
|
|
}
|
|
tables[table.Name] = table
|
|
raw[table.Name] = data
|
|
return nil
|
|
}); err != nil {
|
|
return Dataset{}, err
|
|
}
|
|
manifest := buildManifest(root, version, tables, loadedAt)
|
|
return Dataset{
|
|
root: root,
|
|
version: version,
|
|
tables: tables,
|
|
raw: raw,
|
|
manifest: manifest,
|
|
}, nil
|
|
}
|
|
|
|
func loadOne(root, version, path string, loadedAt time.Time) (Table, []byte, error) {
|
|
data, err := os.ReadFile(path) //nolint:gosec // G304：路径来自框架配置、仓库扫描或测试临时目录，调用点负责限定输入范围。
|
|
if err != nil {
|
|
return Table{}, nil, fmt.Errorf("read data table %q: %w", path, err)
|
|
}
|
|
rows, err := countRows(data)
|
|
if err != nil {
|
|
return Table{}, nil, fmt.Errorf("parse data table %q: %w", path, err)
|
|
}
|
|
rel, err := filepath.Rel(root, path)
|
|
if err != nil {
|
|
return Table{}, nil, fmt.Errorf("resolve data table path %q: %w", path, err)
|
|
}
|
|
rel = filepath.ToSlash(rel)
|
|
name := strings.TrimSuffix(rel, filepath.Ext(rel))
|
|
sum := sha256.Sum256(data)
|
|
return Table{
|
|
Name: name,
|
|
Path: rel,
|
|
Version: version,
|
|
Checksum: hex.EncodeToString(sum[:]),
|
|
Rows: rows,
|
|
Bytes: int64(len(data)),
|
|
LoadedAt: loadedAt,
|
|
}, append([]byte(nil), data...), nil
|
|
}
|
|
|
|
func countRows(data []byte) (int, error) {
|
|
decoder := json.NewDecoder(bytes.NewReader(data))
|
|
decoder.UseNumber()
|
|
var value any
|
|
if err := decoder.Decode(&value); err != nil {
|
|
return 0, err
|
|
}
|
|
var extra any
|
|
if err := decoder.Decode(&extra); err != io.EOF {
|
|
if err == nil {
|
|
return 0, fmt.Errorf("data table contains more than one JSON value")
|
|
}
|
|
return 0, err
|
|
}
|
|
switch typed := value.(type) {
|
|
case []any:
|
|
return len(typed), nil
|
|
case map[string]any:
|
|
if items, ok := typed["items"].([]any); ok {
|
|
return len(items), nil
|
|
}
|
|
return 1, nil
|
|
default:
|
|
return 1, nil
|
|
}
|
|
}
|
|
|
|
func isJSONTable(name string) bool {
|
|
name = strings.TrimSpace(name)
|
|
if name == "" || name == ".DS_Store" || strings.HasPrefix(name, "._") {
|
|
return false
|
|
}
|
|
return strings.EqualFold(filepath.Ext(name), ".json")
|
|
}
|