hanfuit
645b64fe21
服务端（Go）： - GM 塞背包/带属性装备发放：在线角色推送 op14 增量物品行，背包实时刷新，无需回角色选择界面 - GM 改金币/改等级：去掉在线拒绝，落库后推送 op14 钱包/op37 等级状态，在线实时刷新 - 等级端点统一切换到新版 GMSetCharacterLevel（自带在线刷新） - 无限/锁死疲劳模式 + 燃烧疲劳：每房间消耗 2 点、打怪与通关经验双倍 - 燃烧疲劳开关时给所有在线角色推送系统提示（op12 mode 0） - 深渊史诗掉率：GM 全局倍率 + 城镇增益药剂窗口倍率，真实接入掉落结算 启动器（Python/JS）： - 标题栏自绘、窗口 1204x717、禁止拖拽改大小、仅最小化/关闭 - GM 工具：疲劳与燃烧、深渊史诗掉率、拍卖行上架（单一定价对齐） - 拍卖行上架前端对齐服务端单一价格语义，修复 400 报错
238 lines
9.9 KiB
Go
238 lines
9.9 KiB
Go
package dnfbridge
|
|
|
|
import (
|
|
cryptorand "crypto/rand"
|
|
"errors"
|
|
"fmt"
|
|
"math/big"
|
|
|
|
"longheng.io/server/internal/modules/dnf/alignedcmd"
|
|
"longheng.io/server/internal/modules/dnf/dnfenum"
|
|
dnfpvf "longheng.io/server/internal/modules/dnf/pvf"
|
|
)
|
|
|
|
// alignedEnchantBeadResolverForCommand keeps PVF loading request-driven. Only
|
|
// the real current enchant-by-bead command needs this dependency; other
|
|
// aligned commands do not open or scan the item catalog. The resolver follows
|
|
// the active current Script.pvf metadata chain: bead [monster card id] /
|
|
// [enchant index] / [bead limited usable item] (legacy [target item id]), card [string data] equipment-type
|
|
// whitelist and [enchant table]/[enchant index] upgrade-count table, and the
|
|
// target equipment's [equipment type], as authored by the active current
|
|
// Script.pvf.
|
|
func (s *Service) alignedEnchantBeadResolverForCommand(opcode dnfenum.CmdPacket) (alignedcmd.EnchantBeadResolver, error) {
|
|
if opcode != dnfenum.CmdPacketEnchantByBead {
|
|
return nil, nil
|
|
}
|
|
catalog, err := s.currentPVFItemCatalog()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if catalog == nil {
|
|
return nil, errDungeonDropSourceRequired
|
|
}
|
|
s.initialEquipmentMu.Lock()
|
|
source, err := s.initialEquipmentArchiveLocked()
|
|
s.initialEquipmentMu.Unlock()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return func(beadItemID int64, targetItemID int64) (alignedcmd.EnchantBeadResolution, error) {
|
|
return resolveCurrentEnchantBeadMetadata(catalog, source, beadItemID, targetItemID)
|
|
}, nil
|
|
}
|
|
|
|
// resolveCurrentEnchantBeadMetadata resolves one bead/target template pair
|
|
// through the active runtime PVF. Random title enchant beads are resolved
|
|
// before the legacy card fields so they cannot be mistaken for ordinary cards.
|
|
func resolveCurrentEnchantBeadMetadata(catalog *pvfDungeonDropCatalog, source dnfpvf.Source, beadItemID int64, targetItemID int64) (alignedcmd.EnchantBeadResolution, error) {
|
|
if catalog == nil || source == nil {
|
|
return alignedcmd.EnchantBeadResolution{}, errDungeonDropSourceRequired
|
|
}
|
|
if beadItemID <= 0 || beadItemID > int64(^uint32(0)) || targetItemID <= 0 || targetItemID > int64(^uint32(0)) {
|
|
return alignedcmd.EnchantBeadResolution{}, nil
|
|
}
|
|
|
|
resolution := alignedcmd.EnchantBeadResolution{}
|
|
beadDefinition, err := catalog.ResolveItem(uint32(beadItemID))
|
|
if err != nil {
|
|
if errors.Is(err, errDungeonDropItemUnresolved) {
|
|
return resolution, nil
|
|
}
|
|
return alignedcmd.EnchantBeadResolution{}, fmt.Errorf("resolve enchant bead item=%d: %w", beadItemID, err)
|
|
}
|
|
if beadDefinition.Kind != dungeonDropItemStackable {
|
|
return resolution, nil
|
|
}
|
|
beadDocument, err := parseDungeonCardPVFDocument(source, beadDefinition.PVFPath)
|
|
if err != nil {
|
|
return alignedcmd.EnchantBeadResolution{}, fmt.Errorf("parse enchant bead item=%d path=%s: %w", beadItemID, beadDefinition.PVFPath, err)
|
|
}
|
|
resolution.TargetWhitelist = append([]int64(nil), beadDocument.Ints("bead limited usable item")...)
|
|
if len(resolution.TargetWhitelist) == 0 {
|
|
resolution.TargetWhitelist = append([]int64(nil), beadDocument.Ints("target item id")...)
|
|
}
|
|
randomConfigID, randomFound := beadDocument.Int("random title enchant")
|
|
if randomFound {
|
|
// A random bead is a distinct PVF source. Reject ambiguous templates
|
|
// rather than silently preferring one source over the other.
|
|
if _, ordinaryCard := beadDocument.Int("monster card id"); ordinaryCard {
|
|
return alignedcmd.EnchantBeadResolution{}, nil
|
|
}
|
|
if values := beadDocument.Ints("enchant index"); len(values) > 0 {
|
|
return alignedcmd.EnchantBeadResolution{}, nil
|
|
}
|
|
if randomConfigID <= 0 || randomConfigID > 0xffff {
|
|
return resolution, nil
|
|
}
|
|
randomCatalog, catalogErr := parseCurrentRandomTitleEnchantCatalog(source)
|
|
if catalogErr != nil {
|
|
return alignedcmd.EnchantBeadResolution{}, catalogErr
|
|
}
|
|
row, chooseErr := randomCatalog.choose(uint16(randomConfigID))
|
|
if chooseErr != nil {
|
|
return alignedcmd.EnchantBeadResolution{}, chooseErr
|
|
}
|
|
resolution.RandomTitleEnchantConfigID = uint16(randomConfigID)
|
|
resolution.RandomTitleEnchantRowID = row.ID
|
|
resolution.AllowedEquipmentTypes = []string{"[title name]"}
|
|
} else {
|
|
cardItemID, found, chooseErr := chooseCurrentEnchantCardID(beadDocument.Ints("monster card id"))
|
|
if chooseErr != nil {
|
|
return alignedcmd.EnchantBeadResolution{}, chooseErr
|
|
}
|
|
if !found {
|
|
cardItemID, found = beadDocument.Int("enchant index")
|
|
}
|
|
if !found || cardItemID <= 0 || cardItemID > int64(^uint32(0)) {
|
|
return resolution, nil
|
|
}
|
|
resolution.CardItemID = cardItemID
|
|
|
|
cardDefinition, err := catalog.ResolveItem(uint32(cardItemID))
|
|
if err != nil {
|
|
if errors.Is(err, errDungeonDropItemUnresolved) {
|
|
resolution.CardItemID = 0
|
|
return resolution, nil
|
|
}
|
|
return alignedcmd.EnchantBeadResolution{}, fmt.Errorf("resolve enchant card item=%d: %w", cardItemID, err)
|
|
}
|
|
if cardDefinition.Kind != dungeonDropItemStackable {
|
|
resolution.CardItemID = 0
|
|
return resolution, nil
|
|
}
|
|
resolution.CardPVFPath = cardDefinition.PVFPath
|
|
cardDocument, err := parseDungeonCardPVFDocument(source, cardDefinition.PVFPath)
|
|
if err != nil {
|
|
return alignedcmd.EnchantBeadResolution{}, fmt.Errorf("parse enchant card item=%d path=%s: %w", cardItemID, cardDefinition.PVFPath, err)
|
|
}
|
|
// The first [string data] entry is the card icon; the remaining entries
|
|
// are the equipment types the active current Script.pvf allows the card
|
|
// to enchant.
|
|
stringData := cardDocument.Texts("string data")
|
|
if len(stringData) > 1 {
|
|
resolution.AllowedEquipmentTypes = append([]string(nil), stringData[1:]...)
|
|
}
|
|
resolution.UpgradeCounts = currentMonsterCardUpgradeIndices(cardDocument)
|
|
}
|
|
|
|
targetDefinition, err := catalog.ResolveItem(uint32(targetItemID))
|
|
if err != nil {
|
|
if errors.Is(err, errDungeonDropItemUnresolved) {
|
|
return resolution, nil
|
|
}
|
|
return alignedcmd.EnchantBeadResolution{}, fmt.Errorf("resolve enchant target item=%d: %w", targetItemID, err)
|
|
}
|
|
resolution.TargetKind = string(targetDefinition.Kind)
|
|
if targetDefinition.Kind != dungeonDropItemEquipment {
|
|
return resolution, nil
|
|
}
|
|
targetDocument, err := parseDungeonCardPVFDocument(source, targetDefinition.PVFPath)
|
|
if err != nil {
|
|
return alignedcmd.EnchantBeadResolution{}, fmt.Errorf("parse enchant target item=%d path=%s: %w", targetItemID, targetDefinition.PVFPath, err)
|
|
}
|
|
equipmentType, found := targetDocument.Text("equipment type")
|
|
if !found {
|
|
return alignedcmd.EnchantBeadResolution{}, fmt.Errorf("enchant target item=%d path=%s missing [equipment type]", targetItemID, targetDefinition.PVFPath)
|
|
}
|
|
resolution.TargetEquipmentType = equipmentType
|
|
return resolution, nil
|
|
}
|
|
|
|
// chooseCurrentEnchantCardID treats each PVF [monster card id] token as one
|
|
// weighted slot. The live PVF uses repeated IDs to express probability.
|
|
func chooseCurrentEnchantCardID(values []int64) (int64, bool, error) {
|
|
candidates := make([]int64, 0, len(values))
|
|
for _, value := range values {
|
|
if value > 0 && value <= int64(^uint32(0)) {
|
|
candidates = append(candidates, value)
|
|
}
|
|
}
|
|
if len(candidates) == 0 {
|
|
return 0, false, nil
|
|
}
|
|
if len(candidates) == 1 {
|
|
return candidates[0], true, nil
|
|
}
|
|
roll, err := cryptorand.Int(cryptorand.Reader, big.NewInt(int64(len(candidates))))
|
|
if err != nil {
|
|
return 0, false, fmt.Errorf("random enchant card roll: %w", err)
|
|
}
|
|
return candidates[roll.Int64()], true, nil
|
|
}
|
|
|
|
// resolveCurrentEnchantCardMetadata validates a raw monster card used through
|
|
// an enchanter player store. Unlike the bead command, the supplied stack is
|
|
// already the card, so no bead-to-card indirection or target-item whitelist is
|
|
// involved; the card's PVF equipment-type and upgrade-count tables remain
|
|
// authoritative.
|
|
func resolveCurrentEnchantCardMetadata(catalog *pvfDungeonDropCatalog, source dnfpvf.Source, cardItemID, targetItemID int64) (alignedcmd.EnchantBeadResolution, error) {
|
|
resolution := alignedcmd.EnchantBeadResolution{CardItemID: cardItemID}
|
|
if catalog == nil || source == nil {
|
|
return alignedcmd.EnchantBeadResolution{}, errDungeonDropSourceRequired
|
|
}
|
|
if cardItemID <= 0 || cardItemID > int64(^uint32(0)) || targetItemID <= 0 || targetItemID > int64(^uint32(0)) {
|
|
return alignedcmd.EnchantBeadResolution{}, nil
|
|
}
|
|
cardDefinition, err := catalog.ResolveItem(uint32(cardItemID))
|
|
if err != nil {
|
|
if errors.Is(err, errDungeonDropItemUnresolved) {
|
|
return alignedcmd.EnchantBeadResolution{}, nil
|
|
}
|
|
return alignedcmd.EnchantBeadResolution{}, fmt.Errorf("resolve enchant card item=%d: %w", cardItemID, err)
|
|
}
|
|
if cardDefinition.Kind != dungeonDropItemStackable {
|
|
return alignedcmd.EnchantBeadResolution{}, nil
|
|
}
|
|
resolution.CardPVFPath = cardDefinition.PVFPath
|
|
cardDocument, err := parseDungeonCardPVFDocument(source, cardDefinition.PVFPath)
|
|
if err != nil {
|
|
return alignedcmd.EnchantBeadResolution{}, fmt.Errorf("parse enchant card item=%d path=%s: %w", cardItemID, cardDefinition.PVFPath, err)
|
|
}
|
|
stringData := cardDocument.Texts("string data")
|
|
if len(stringData) > 1 {
|
|
resolution.AllowedEquipmentTypes = append([]string(nil), stringData[1:]...)
|
|
}
|
|
resolution.UpgradeCounts = currentMonsterCardUpgradeIndices(cardDocument)
|
|
targetDefinition, err := catalog.ResolveItem(uint32(targetItemID))
|
|
if err != nil {
|
|
if errors.Is(err, errDungeonDropItemUnresolved) {
|
|
return resolution, nil
|
|
}
|
|
return alignedcmd.EnchantBeadResolution{}, fmt.Errorf("resolve enchant target item=%d: %w", targetItemID, err)
|
|
}
|
|
resolution.TargetKind = string(targetDefinition.Kind)
|
|
if targetDefinition.Kind != dungeonDropItemEquipment {
|
|
return resolution, nil
|
|
}
|
|
targetDocument, err := parseDungeonCardPVFDocument(source, targetDefinition.PVFPath)
|
|
if err != nil {
|
|
return alignedcmd.EnchantBeadResolution{}, fmt.Errorf("parse enchant target item=%d path=%s: %w", targetItemID, targetDefinition.PVFPath, err)
|
|
}
|
|
equipmentType, found := targetDocument.Text("equipment type")
|
|
if !found {
|
|
return alignedcmd.EnchantBeadResolution{}, fmt.Errorf("enchant target item=%d path=%s missing [equipment type]", targetItemID, targetDefinition.PVFPath)
|
|
}
|
|
resolution.TargetEquipmentType = equipmentType
|
|
return resolution, nil
|
|
}
|