DNF90 服务端与启动器完整源码（含 GM 工具功能增强）
服务端（Go）： - GM 塞背包/带属性装备发放：在线角色推送 op14 增量物品行，背包实时刷新，无需回角色选择界面 - GM 改金币/改等级：去掉在线拒绝，落库后推送 op14 钱包/op37 等级状态，在线实时刷新 - 等级端点统一切换到新版 GMSetCharacterLevel（自带在线刷新） - 无限/锁死疲劳模式 + 燃烧疲劳：每房间消耗 2 点、打怪与通关经验双倍 - 燃烧疲劳开关时给所有在线角色推送系统提示（op12 mode 0） - 深渊史诗掉率：GM 全局倍率 + 城镇增益药剂窗口倍率，真实接入掉落结算 启动器（Python/JS）： - 标题栏自绘、窗口 1204x717、禁止拖拽改大小、仅最小化/关闭 - GM 工具：疲劳与燃烧、深渊史诗掉率、拍卖行上架（单一定价对齐） - 拍卖行上架前端对齐服务端单一价格语义，修复 400 报错
This commit is contained in:
hanfuit committed
commit
645b64fe21
4388 files changed
+1405457
No files matched your search
@@ -0,0 +1,264 @@
|
||||
package services
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"fmt"
|
||||
"reflect"
|
||||
"slices"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"pvfine/internal/pvf"
|
||||
)
|
||||
|
||||
func referencePipelineFixture(t testing.TB, files, tokens int) (*core, *advancedSQLite, []byte) {
|
||||
t.Helper()
|
||||
a := pvf.New()
|
||||
raw := make([]byte, tokens*5)
|
||||
for i := 0; i < tokens; i++ {
|
||||
raw[i*5] = []byte{3, 5, 6, 7}[i%4]
|
||||
binary.LittleEndian.PutUint32(raw[i*5+1:], uint32(a.StringOffset(fmt.Sprintf("value-%d", i%67))))
|
||||
}
|
||||
for i := 0; i < files; i++ {
|
||||
a.AddFile(fmt.Sprintf("dir/%d.equ", i), raw, pvf.TypeScript)
|
||||
}
|
||||
var buf bytes.Buffer
|
||||
if err := a.SaveTo(&buf); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
a, err := pvf.Parse(buf.Bytes())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
d := &advancedSQLite{ctx: ctx, cancel: cancel, closed: make(chan struct{})}
|
||||
t.Cleanup(d.close)
|
||||
return &core{archive: a, advancedDisk: d}, d, buf.Bytes()
|
||||
}
|
||||
|
||||
func TestAdvancedReferencePipelineMatchesSequential(t *testing.T) {
|
||||
for _, workers := range []int{1, 4} {
|
||||
t.Run(fmt.Sprint(workers), func(t *testing.T) {
|
||||
c, d, _ := referencePipelineFixture(t, 129, 1000)
|
||||
a := c.archive
|
||||
if err := a.SetRawBytes(0, []byte{7, 0, 0, 0, 0}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
a.AddFile("extra/new.equ", nil, pvf.TypeScript)
|
||||
a.AddFile("extra/text.str", []byte{7, 0, 0, 0, 0}, pvf.TypeUnicode)
|
||||
want := make(map[int32]advancedReferenceResult)
|
||||
scanner := a.NewStringReferenceScanner()
|
||||
for {
|
||||
index, refs, ok, err := scanner.Next(d.ctx)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !ok {
|
||||
break
|
||||
}
|
||||
want[index] = advancedReferenceResult{index: index, path: a.Path(index), file: a.File(index), refs: refs, refCount: len(refs)}
|
||||
}
|
||||
p := d.startReferencePipeline(c, a, a.NewStringReferenceScanner(), workers, nil)
|
||||
defer p.close()
|
||||
for got := range p.results {
|
||||
if !reflect.DeepEqual(got, want[got.index]) {
|
||||
t.Fatalf("different or duplicate result for file %d", got.index)
|
||||
}
|
||||
delete(want, got.index)
|
||||
}
|
||||
if err := p.err(); err != nil || len(want) != 0 {
|
||||
t.Fatalf("missing=%d err=%v", len(want), err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdvancedReferencePipelineStopsWithBlockedWriter(t *testing.T) {
|
||||
for _, action := range []string{"writer-error", "cancel", "archive-replaced"} {
|
||||
t.Run(action, func(t *testing.T) {
|
||||
c, d, _ := referencePipelineFixture(t, 129, 1000)
|
||||
a := c.archive
|
||||
p := d.startReferencePipeline(c, a, a.NewStringReferenceScanner(), 4, nil)
|
||||
defer p.close()
|
||||
select {
|
||||
case <-p.results:
|
||||
case <-time.After(5 * time.Second):
|
||||
t.Fatal("reader did not start")
|
||||
}
|
||||
switch action {
|
||||
case "writer-error":
|
||||
go p.close()
|
||||
case "cancel":
|
||||
d.cancel()
|
||||
case "archive-replaced":
|
||||
c.mu.Lock()
|
||||
c.archive = nil
|
||||
c.mu.Unlock()
|
||||
// Let the reader reach its next identity check.
|
||||
go func() {
|
||||
for range p.results {
|
||||
}
|
||||
}()
|
||||
}
|
||||
select {
|
||||
case <-p.done:
|
||||
case <-time.After(5 * time.Second):
|
||||
t.Fatal("pipeline goroutines did not exit")
|
||||
}
|
||||
if !errors.Is(p.err(), context.Canceled) {
|
||||
t.Fatalf("unexpected cancellation: %v", p.err())
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdvancedReferencePipelineReadError(t *testing.T) {
|
||||
c, d, source := referencePipelineFixture(t, 8, 100)
|
||||
// Deliberately damage retained source bytes after parsing to exercise a
|
||||
// decompression failure; ordinary callers must treat these bytes as read-only.
|
||||
clear(source)
|
||||
a := c.archive
|
||||
p := d.startReferencePipeline(c, a, a.NewStringReferenceScanner(), 4, nil)
|
||||
defer p.close()
|
||||
for range p.results {
|
||||
t.Fatal("corrupt chunk produced a result")
|
||||
}
|
||||
if err := p.err(); err == nil || errors.Is(err, context.Canceled) {
|
||||
t.Fatalf("reader error was lost: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdvancedReferencePipelineWriteError(t *testing.T) {
|
||||
c, d, _ := referencePipelineFixture(t, 32, 100)
|
||||
a := c.archive
|
||||
want := errors.New("injected shard write failure")
|
||||
p := d.startReferencePipeline(c, a, a.NewStringReferenceScanner(), 4, func(_ context.Context, _ int, _ advancedReferenceResult) error {
|
||||
return want
|
||||
})
|
||||
defer p.close()
|
||||
select {
|
||||
case <-p.done:
|
||||
case <-time.After(5 * time.Second):
|
||||
t.Fatal("shard failure left workers blocked")
|
||||
}
|
||||
if !errors.Is(p.err(), want) {
|
||||
t.Fatalf("lost shard failure: %v", p.err())
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkAdvancedReferencePipeline(b *testing.B) {
|
||||
for _, workers := range []int{1, 4} {
|
||||
b.Run(fmt.Sprintf("workers-%d", workers), func(b *testing.B) {
|
||||
c, d, _ := referencePipelineFixture(b, 256, 16000)
|
||||
a := c.archive
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
p := d.startReferencePipeline(c, a, a.NewStringReferenceScanner(), workers, nil)
|
||||
for range p.results {
|
||||
}
|
||||
err := p.err()
|
||||
p.close()
|
||||
if err != nil {
|
||||
b.Fatal(err)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdvancedReferencePipelineWriterConsumesBeforeReuse(t *testing.T) {
|
||||
c, d, _ := referencePipelineFixture(t, 129, 1000)
|
||||
a := c.archive
|
||||
// Vary result sizes so a later parse cannot silently replace an earlier
|
||||
// file's count. Shared field offsets and token ordering are checked too.
|
||||
for i := int32(0); i < a.FileCount(); i += 7 {
|
||||
if err := a.SetRawBytes(i, []byte{7, 0, 0, 0, 0}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
want := make(map[int32]advancedReferenceResult)
|
||||
scanner := a.NewStringReferenceScanner()
|
||||
for {
|
||||
index, refs, ok, err := scanner.Next(d.ctx)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !ok {
|
||||
break
|
||||
}
|
||||
want[index] = advancedReferenceResult{index: index, path: a.Path(index), file: a.File(index), refs: refs, refCount: len(refs)}
|
||||
}
|
||||
var mu sync.Mutex
|
||||
written := make(map[int32]bool)
|
||||
p := d.startReferencePipeline(c, a, a.NewStringReferenceScanner(), 4, func(_ context.Context, _ int, result advancedReferenceResult) error {
|
||||
expected := want[result.index]
|
||||
// Reused empty slices can have non-nil backing storage. Compare their
|
||||
// values, including order, rather than allocation details.
|
||||
refsEqual := slices.EqualFunc(result.refs, expected.refs, func(left, right pvf.StringReference) bool {
|
||||
return left.Offset == right.Offset && left.Occurrences == right.Occurrences && slices.Equal(left.TokenTypes, right.TokenTypes) && slices.Equal(left.FileFields, right.FileFields)
|
||||
})
|
||||
if result.refCount != expected.refCount || result.path != expected.path || !reflect.DeepEqual(result.file, expected.file) || !refsEqual {
|
||||
return fmt.Errorf("writer received incorrect references for file %d", result.index)
|
||||
}
|
||||
mu.Lock()
|
||||
defer mu.Unlock()
|
||||
if written[result.index] {
|
||||
return fmt.Errorf("writer received duplicate file %d", result.index)
|
||||
}
|
||||
written[result.index] = true
|
||||
return nil
|
||||
})
|
||||
defer p.close()
|
||||
received := make(map[int32]bool)
|
||||
for result := range p.results {
|
||||
expected, ok := want[result.index]
|
||||
if !ok || received[result.index] || result.refs != nil || result.refCount != expected.refCount || result.path != expected.path || !reflect.DeepEqual(result.file, expected.file) {
|
||||
t.Fatalf("channel published borrowed or incorrect result for file %d", result.index)
|
||||
}
|
||||
mu.Lock()
|
||||
done := written[result.index]
|
||||
mu.Unlock()
|
||||
if !done {
|
||||
t.Fatal("channel result arrived before synchronous writer finished")
|
||||
}
|
||||
received[result.index] = true
|
||||
}
|
||||
if err := p.err(); err != nil || len(received) != len(want) {
|
||||
t.Fatalf("pipeline failed: received=%d want=%d err=%v", len(received), len(want), err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdvancedReferencePipelineCancelsBlockedSynchronousWriter(t *testing.T) {
|
||||
c, d, _ := referencePipelineFixture(t, 129, 1000)
|
||||
started := make(chan struct{}, 1)
|
||||
p := d.startReferencePipeline(c, c.archive, c.archive.NewStringReferenceScanner(), 4, func(ctx context.Context, _ int, _ advancedReferenceResult) error {
|
||||
select {
|
||||
case started <- struct{}{}:
|
||||
default:
|
||||
}
|
||||
<-ctx.Done()
|
||||
return ctx.Err()
|
||||
})
|
||||
defer p.close()
|
||||
select {
|
||||
case <-started:
|
||||
case <-time.After(5 * time.Second):
|
||||
t.Fatal("writer did not start")
|
||||
}
|
||||
d.cancel()
|
||||
select {
|
||||
case <-p.done:
|
||||
case <-time.After(5 * time.Second):
|
||||
t.Fatal("cancellation left writer or reader blocked")
|
||||
}
|
||||
if !errors.Is(p.err(), context.Canceled) {
|
||||
t.Fatalf("lost cancellation: %v", p.err())
|
||||
}
|
||||
for range p.results {
|
||||
t.Fatal("canceled writer published a result")
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user