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,258 @@
+package combatpower
+
+import (
+	"context"
+	"fmt"
+	"path"
+	"sort"
+	"strings"
+	"sync"
+
+	dnfpvf "longheng.io/server/internal/modules/dnf/pvf"
+)
+
+const (
+	equipmentListPath = "equipment/equipment.lst"
+	partSetListPath   = "etc/equipmentpartset.etc"
+)
+
+type Catalog struct {
+	source dnfpvf.Source
+
+	mu        sync.Mutex
+	itemPaths map[int64]string
+	setPaths  map[int64]string
+	items     map[int64]ItemDefinition
+	sets      map[int64]SetDefinition
+}
+
+func Load(ctx context.Context, source dnfpvf.Source) (*Catalog, error) {
+	if source == nil {
+		return nil, ErrSourceRequired
+	}
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+
+	equipmentText, err := source.ReadText(equipmentListPath)
+	if err != nil {
+		return nil, fmt.Errorf("read combat power equipment list: %w", err)
+	}
+	equipmentDoc, err := dnfpvf.Parse(equipmentListPath, equipmentText)
+	if err != nil {
+		return nil, fmt.Errorf("parse combat power equipment list: %w", err)
+	}
+	itemPaths := make(map[int64]string)
+	for _, entry := range dnfpvf.ParseList(equipmentDoc) {
+		if entry.ID <= 0 {
+			continue
+		}
+		itemPaths[entry.ID] = resolvePVFReference(equipmentListPath, entry.Path)
+	}
+
+	setText, err := source.ReadText(partSetListPath)
+	if err != nil {
+		return nil, fmt.Errorf("read combat power part-set list: %w", err)
+	}
+	setDoc, err := dnfpvf.Parse(partSetListPath, setText)
+	if err != nil {
+		return nil, fmt.Errorf("parse combat power part-set list: %w", err)
+	}
+	setPaths := parsePartSetPaths(setDoc)
+
+	return &Catalog{
+		source:    source,
+		itemPaths: itemPaths,
+		setPaths:  setPaths,
+		items:     make(map[int64]ItemDefinition),
+		sets:      make(map[int64]SetDefinition),
+	}, nil
+}
+
+func (c *Catalog) Snapshot() (items, sets int) {
+	if c == nil {
+		return 0, 0
+	}
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return len(c.itemPaths), len(c.setPaths)
+}
+
+func (c *Catalog) Aggregate(ctx context.Context, itemIDs []int64) (Result, error) {
+	if c == nil || c.source == nil {
+		return Result{}, ErrSourceRequired
+	}
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	result := Result{}
+	setPieces := make(map[int64]int)
+	for _, itemID := range itemIDs {
+		if err := ctx.Err(); err != nil {
+			return Result{}, err
+		}
+		if itemID <= 0 {
+			continue
+		}
+		item, err := c.item(ctx, itemID)
+		if err != nil {
+			return Result{}, err
+		}
+		result.Affixes.Add(item.Affixes)
+		result.EquippedItems++
+		if item.EquipmentScore > 0 {
+			result.ScoredItems++
+			result.PVFEquipmentScore += item.EquipmentScore
+		}
+		if item.Rarity == 4 && item.MinimumLevel >= 90 {
+			result.Level90EpicItems++
+		}
+		if item.PartSetID > 0 {
+			setPieces[item.PartSetID]++
+		}
+	}
+
+	setIDs := make([]int64, 0, len(setPieces))
+	for setID := range setPieces {
+		setIDs = append(setIDs, setID)
+	}
+	sort.Slice(setIDs, func(i, j int) bool { return setIDs[i] < setIDs[j] })
+	for _, setID := range setIDs {
+		pieces := setPieces[setID]
+		definition, err := c.set(ctx, setID)
+		if err != nil {
+			return Result{}, err
+		}
+		active := false
+		for _, ability := range definition.Abilities {
+			if ability.RequiredPieces <= 0 || pieces < ability.RequiredPieces {
+				continue
+			}
+			result.Affixes.Add(ability.Affixes)
+			active = true
+		}
+		if active {
+			result.ActiveSets = append(result.ActiveSets, ActiveSet{ID: setID, Pieces: pieces})
+		}
+	}
+	return result, nil
+}
+
+func (c *Catalog) item(ctx context.Context, itemID int64) (ItemDefinition, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if item, ok := c.items[itemID]; ok {
+		return item, nil
+	}
+	itemPath := c.itemPaths[itemID]
+	if itemPath == "" {
+		return ItemDefinition{}, fmt.Errorf("%w: item %d", ErrItemMissing, itemID)
+	}
+	if err := ctx.Err(); err != nil {
+		return ItemDefinition{}, err
+	}
+	text, err := c.source.ReadText(itemPath)
+	if err != nil {
+		return ItemDefinition{}, fmt.Errorf("read combat power item %d at %s: %w", itemID, itemPath, err)
+	}
+	doc, err := dnfpvf.Parse(itemPath, text)
+	if err != nil {
+		return ItemDefinition{}, fmt.Errorf("parse combat power item %d at %s: %w", itemID, itemPath, err)
+	}
+	partSetID, _ := doc.Int("part set index")
+	rarity, _ := doc.Int("rarity")
+	minimumLevel, _ := doc.Int("minimum level")
+	grade, _ := doc.Int("grade")
+	equipmentType, _ := doc.Text("equipment type")
+	item := ItemDefinition{
+		ID:            itemID,
+		Path:          itemPath,
+		PartSetID:     partSetID,
+		Rarity:        boundedPVFScoreMetadata(rarity, 10),
+		MinimumLevel:  boundedPVFScoreMetadata(minimumLevel, 200),
+		Grade:         boundedPVFScoreMetadata(grade, 200),
+		EquipmentType: strings.TrimSpace(equipmentType),
+		Affixes:       parseDocumentAffixes(doc),
+	}
+	item.EquipmentScore = pvfEquipmentBaseScore(item)
+	c.items[itemID] = item
+	return item, nil
+}
+
+// pvfEquipmentBaseScore is the local V6 calibration for the equipment-grade
+// part of the TGP-style display. The original TGP coefficients were never
+// published, so this must remain an explicit, auditable projection from the
+// runtime PVF instead of an item-ID table: required level carries the largest
+// weight, PVF grade refines items at the same level, and rarity is the final
+// quality tier. Every current actor slot (including avatars, creature and
+// creature artifacts) is eligible when its authoritative PVF document carries
+// these fields.
+func pvfEquipmentBaseScore(item ItemDefinition) int {
+	return item.MinimumLevel*20 + item.Grade*5 + item.Rarity*100
+}
+
+func boundedPVFScoreMetadata(value int64, maximum int) int {
+	if value <= 0 {
+		return 0
+	}
+	if value >= int64(maximum) {
+		return maximum
+	}
+	return int(value)
+}
+
+func (c *Catalog) set(ctx context.Context, setID int64) (SetDefinition, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if definition, ok := c.sets[setID]; ok {
+		return definition, nil
+	}
+	setPath := c.setPaths[setID]
+	if setPath == "" {
+		return SetDefinition{}, fmt.Errorf("%w: part set %d", ErrItemMissing, setID)
+	}
+	if err := ctx.Err(); err != nil {
+		return SetDefinition{}, err
+	}
+	text, err := c.source.ReadText(setPath)
+	if err != nil {
+		return SetDefinition{}, fmt.Errorf("read combat power part set %d at %s: %w", setID, setPath, err)
+	}
+	doc, err := dnfpvf.Parse(setPath, text)
+	if err != nil {
+		return SetDefinition{}, fmt.Errorf("parse combat power part set %d at %s: %w", setID, setPath, err)
+	}
+	definition := SetDefinition{ID: setID, Path: setPath, Abilities: parseSetAbilities(doc)}
+	c.sets[setID] = definition
+	return definition, nil
+}
+
+func parsePartSetPaths(doc *dnfpvf.Document) map[int64]string {
+	out := make(map[int64]string)
+	if doc == nil {
+		return out
+	}
+	for index := 0; index+1 < len(doc.Tokens); index++ {
+		id := doc.Tokens[index]
+		ref := doc.Tokens[index+1]
+		if id.Kind != dnfpvf.TokenInt || id.Int <= 0 ||
+			(ref.Kind != dnfpvf.TokenString && ref.Kind != dnfpvf.TokenIdent) ||
+			!strings.HasSuffix(strings.ToLower(strings.TrimSpace(ref.Value)), ".equ") {
+			continue
+		}
+		out[id.Int] = resolvePVFReference("equipment/equipmentpartset.etc", ref.Value)
+	}
+	return out
+}
+
+func resolvePVFReference(listPath, reference string) string {
+	reference = strings.TrimSpace(strings.Trim(reference, "`\"'"))
+	reference = strings.ReplaceAll(reference, "\\", "/")
+	if strings.HasPrefix(strings.ToLower(reference), "equipment/") {
+		return path.Clean(reference)
+	}
+	return path.Clean(path.Join(path.Dir(listPath), reference))
+}