hanfuit
645b64fe21
服务端（Go）： - GM 塞背包/带属性装备发放：在线角色推送 op14 增量物品行，背包实时刷新，无需回角色选择界面 - GM 改金币/改等级：去掉在线拒绝，落库后推送 op14 钱包/op37 等级状态，在线实时刷新 - 等级端点统一切换到新版 GMSetCharacterLevel（自带在线刷新） - 无限/锁死疲劳模式 + 燃烧疲劳：每房间消耗 2 点、打怪与通关经验双倍 - 燃烧疲劳开关时给所有在线角色推送系统提示（op12 mode 0） - 深渊史诗掉率：GM 全局倍率 + 城镇增益药剂窗口倍率，真实接入掉落结算 启动器（Python/JS）： - 标题栏自绘、窗口 1204x717、禁止拖拽改大小、仅最小化/关闭 - GM 工具：疲劳与燃烧、深渊史诗掉率、拍卖行上架（单一定价对齐） - 拍卖行上架前端对齐服务端单一价格语义，修复 400 报错
404 lines
14 KiB
Go
404 lines
14 KiB
Go
package dnfbridge
|
|
|
|
import (
|
|
"context"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"math"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
dnfcharstat "longheng.io/server/internal/modules/dnf/charstat"
|
|
dnfcombatpower "longheng.io/server/internal/modules/dnf/combatpower"
|
|
dnfrepo "longheng.io/server/internal/modules/dnf/repository"
|
|
)
|
|
|
|
// Class0/op413 type 1 is the DLL-private compatibility envelope for the exact
|
|
// PVF combat snapshot. Seria-luck HUD state is deliberately not sent
|
|
// through this private opcode; that display belongs to the native EXE path.
|
|
//
|
|
// Wire contract (must match the shipped client DLL byte for byte):
|
|
// - 16-byte class0 header + 70-byte body = 86-byte packet
|
|
// - body[0] == type 1, body[1] == version 4
|
|
//
|
|
// The client patch (90CN.dll TryConsumePrivateCombatPowerAffixes) rejects the
|
|
// packet unless opcode==413, length==86, type==1 and version==4, so a v5 body
|
|
// with a trailing character id is dropped silently and the panel loses every
|
|
// equipment/affix row. Keep version 4 and 70 bytes unless the client DLL is
|
|
// rebuilt with the matching constants.
|
|
const (
|
|
currentCombatPowerAffixMsgID = uint16(413)
|
|
currentCombatPowerAffixType = byte(1)
|
|
currentCombatPowerAffixVersion = byte(4)
|
|
currentCombatPowerAffixBodyLength = 70
|
|
currentCombatPowerAffixPrivateABI = "90cn_private_combat_power_affixes_v4"
|
|
currentCombatPowerProfessionBytes = 32
|
|
)
|
|
|
|
type currentCombatPowerProjection struct {
|
|
Result dnfcombatpower.Result
|
|
Job byte
|
|
GrowType byte
|
|
Level byte
|
|
ProfessionName string
|
|
Stats dnfcharstat.Vector
|
|
CharacterID uint32
|
|
}
|
|
|
|
func (s *Service) preloadCombatPowerAffixCatalog(ctx context.Context) error {
|
|
if s == nil {
|
|
return fmt.Errorf("dnfbridge service is nil")
|
|
}
|
|
s.combatPowerMu.Lock()
|
|
if s.combatPowerCatalog != nil {
|
|
s.combatPowerMu.Unlock()
|
|
return nil
|
|
}
|
|
if s.combatPowerCatalogErr != nil {
|
|
err := s.combatPowerCatalogErr
|
|
s.combatPowerMu.Unlock()
|
|
return err
|
|
}
|
|
s.combatPowerMu.Unlock()
|
|
|
|
s.initialEquipmentMu.Lock()
|
|
archive, err := s.initialEquipmentArchiveLocked()
|
|
s.initialEquipmentMu.Unlock()
|
|
if err != nil {
|
|
return fmt.Errorf("load combat power pvf archive: %w", err)
|
|
}
|
|
catalog, err := dnfcombatpower.Load(ctx, archive)
|
|
|
|
s.combatPowerMu.Lock()
|
|
defer s.combatPowerMu.Unlock()
|
|
if err != nil {
|
|
s.combatPowerCatalogErr = fmt.Errorf("load combat power affix catalog: %w", err)
|
|
return s.combatPowerCatalogErr
|
|
}
|
|
s.combatPowerCatalog = catalog
|
|
items, sets := catalog.Snapshot()
|
|
s.logPacketEvent("dnf-combat-power-affix-pvf-catalog-loaded", "items", items, "sets", sets)
|
|
return nil
|
|
}
|
|
|
|
func buildCurrentCombatPowerAffixBody(projection currentCombatPowerProjection) []byte {
|
|
result := projection.Result
|
|
body := make([]byte, currentCombatPowerAffixBodyLength)
|
|
body[0] = currentCombatPowerAffixType
|
|
body[1] = currentCombatPowerAffixVersion
|
|
binary.LittleEndian.PutUint16(body[2:4], combatPowerPercentTenths(result.Affixes.WhiteDamage))
|
|
binary.LittleEndian.PutUint16(body[4:6], combatPowerPercentTenths(result.Affixes.YellowDamage))
|
|
binary.LittleEndian.PutUint16(body[6:8], combatPowerPercentTenths(result.Affixes.CriticalDamage))
|
|
binary.LittleEndian.PutUint16(body[8:10], combatPowerPercentTenths(result.Affixes.YellowAdditional))
|
|
binary.LittleEndian.PutUint16(body[10:12], combatPowerPercentTenths(result.Affixes.CriticalAdditional))
|
|
binary.LittleEndian.PutUint16(body[12:14], combatPowerPercentTenths(result.Affixes.AllAttack))
|
|
binary.LittleEndian.PutUint16(body[14:16], clampUint16(result.EquippedItems))
|
|
binary.LittleEndian.PutUint16(body[16:18], clampUint16(len(result.ActiveSets)))
|
|
body[18] = projection.Job
|
|
body[19] = projection.GrowType
|
|
body[20] = projection.Level
|
|
profession := boundedCombatPowerProfession(projection.ProfessionName)
|
|
body[21] = byte(len(profession))
|
|
binary.LittleEndian.PutUint32(body[22:26], clampUint32(projection.Stats.PhysicalAttack))
|
|
binary.LittleEndian.PutUint32(body[26:30], clampUint32(projection.Stats.MagicalAttack))
|
|
binary.LittleEndian.PutUint32(body[30:34], clampUint32(projection.Stats.IndependentAttack))
|
|
copy(body[34:34+currentCombatPowerProfessionBytes], profession)
|
|
binary.LittleEndian.PutUint32(body[66:70], clampUint32(int64(result.PVFEquipmentScore)))
|
|
return body
|
|
}
|
|
|
|
func boundedCombatPowerProfession(value string) []byte {
|
|
value = strings.TrimSpace(value)
|
|
if value == "" {
|
|
return nil
|
|
}
|
|
const maximum = currentCombatPowerProfessionBytes - 1
|
|
out := make([]byte, 0, maximum)
|
|
for _, character := range value {
|
|
encoded := []byte(string(character))
|
|
if len(out)+len(encoded) > maximum {
|
|
break
|
|
}
|
|
out = append(out, encoded...)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func combatPowerPercentTenths(value float64) uint16 {
|
|
if value <= 0 || math.IsNaN(value) || math.IsInf(value, 0) {
|
|
return 0
|
|
}
|
|
value = math.Round(value * 10)
|
|
if value >= math.MaxUint16 {
|
|
return math.MaxUint16
|
|
}
|
|
return uint16(value)
|
|
}
|
|
|
|
func clampUint16(value int) uint16 {
|
|
if value <= 0 {
|
|
return 0
|
|
}
|
|
if value >= math.MaxUint16 {
|
|
return math.MaxUint16
|
|
}
|
|
return uint16(value)
|
|
}
|
|
|
|
func clampUint32(value int64) uint32 {
|
|
if value <= 0 {
|
|
return 0
|
|
}
|
|
if value >= math.MaxUint32 {
|
|
return math.MaxUint32
|
|
}
|
|
return uint32(value)
|
|
}
|
|
|
|
func (s *Service) sendSelectedCurrentCombatPowerAffixes(session *gameSession, source string) error {
|
|
_, err := s.sendSelectedCurrentCombatPowerAffixProjection(session, source)
|
|
return err
|
|
}
|
|
|
|
func (s *Service) sendSelectedCurrentCombatPowerAffixProjection(session *gameSession, source string) (bool, error) {
|
|
if s == nil || session == nil || session.selectedCharacterID == 0 {
|
|
return false, nil
|
|
}
|
|
s.combatPowerMu.Lock()
|
|
catalog := s.combatPowerCatalog
|
|
catalogErr := s.combatPowerCatalogErr
|
|
s.combatPowerMu.Unlock()
|
|
if catalog == nil {
|
|
s.logGameEvent(session, "game-combat-power-affix-private-projection-deferred",
|
|
"source", source,
|
|
"char_id", session.selectedCharacterID,
|
|
"private_abi", currentCombatPowerAffixPrivateABI,
|
|
"reason", "pvf_catalog_unavailable",
|
|
"error", catalogErr)
|
|
return false, nil
|
|
}
|
|
repositories, ok := s.repositoryGroup()
|
|
if !ok || repositories.Character == nil || repositories.Equipment == nil {
|
|
s.logGameEvent(session, "game-combat-power-affix-private-projection-deferred",
|
|
"source", source,
|
|
"char_id", session.selectedCharacterID,
|
|
"private_abi", currentCombatPowerAffixPrivateABI,
|
|
"reason", "character_or_equipment_repository_unavailable")
|
|
return false, nil
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), createWriteTimeout)
|
|
defer cancel()
|
|
characterID := strconv.Itoa(int(session.selectedCharacterID))
|
|
character, characterFound, err := repositories.Character.Load(ctx, characterID)
|
|
if err != nil || !characterFound {
|
|
s.logGameEvent(session, "game-combat-power-affix-private-projection-deferred",
|
|
"source", source,
|
|
"char_id", session.selectedCharacterID,
|
|
"private_abi", currentCombatPowerAffixPrivateABI,
|
|
"reason", "character_load_failed",
|
|
"found", characterFound,
|
|
"error", err)
|
|
return false, nil
|
|
}
|
|
jobValue, err := strconv.Atoi(strings.TrimSpace(character.Job))
|
|
if err != nil || jobValue < 0 || jobValue > math.MaxUint8 {
|
|
s.logGameEvent(session, "game-combat-power-affix-private-projection-deferred",
|
|
"source", source,
|
|
"char_id", session.selectedCharacterID,
|
|
"private_abi", currentCombatPowerAffixPrivateABI,
|
|
"reason", "character_job_invalid",
|
|
"job", character.Job,
|
|
"error", err)
|
|
return false, nil
|
|
}
|
|
growType := byte(numericCharacterStatValue(character, "grow_type"))
|
|
profiles, _, err := s.currentProfessionResources(ctx)
|
|
if err != nil {
|
|
s.logGameEvent(session, "game-combat-power-affix-private-projection-deferred",
|
|
"source", source,
|
|
"char_id", session.selectedCharacterID,
|
|
"private_abi", currentCombatPowerAffixPrivateABI,
|
|
"reason", "profession_profile_unavailable",
|
|
"error", err)
|
|
return false, nil
|
|
}
|
|
professionName, professionFound := profiles.DisplayName(byte(jobValue), growType)
|
|
if !professionFound {
|
|
s.logGameEvent(session, "game-combat-power-affix-private-projection-deferred",
|
|
"source", source,
|
|
"char_id", session.selectedCharacterID,
|
|
"private_abi", currentCombatPowerAffixPrivateABI,
|
|
"reason", "profession_name_missing",
|
|
"job", jobValue,
|
|
"grow_type", growType)
|
|
return false, nil
|
|
}
|
|
stats, statsFound := s.characterPVFStatsForUserInfo(ctx, session, character, true)
|
|
if !statsFound {
|
|
s.logGameEvent(session, "game-combat-power-affix-private-projection-deferred",
|
|
"source", source,
|
|
"char_id", session.selectedCharacterID,
|
|
"private_abi", currentCombatPowerAffixPrivateABI,
|
|
"reason", "character_three_attack_stats_unavailable")
|
|
return false, nil
|
|
}
|
|
equipment, equipmentFound, err := repositories.Equipment.Load(ctx, characterID)
|
|
if err != nil {
|
|
s.logGameEvent(session, "game-combat-power-affix-private-projection-deferred",
|
|
"source", source,
|
|
"char_id", session.selectedCharacterID,
|
|
"private_abi", currentCombatPowerAffixPrivateABI,
|
|
"reason", "equipment_load_failed",
|
|
"error", err)
|
|
return false, nil
|
|
}
|
|
if repositories.Pet == nil {
|
|
s.logGameEvent(session, "game-combat-power-affix-private-projection-deferred",
|
|
"source", source,
|
|
"char_id", session.selectedCharacterID,
|
|
"private_abi", currentCombatPowerAffixPrivateABI,
|
|
"reason", "pet_repository_unavailable")
|
|
return false, nil
|
|
}
|
|
petRecord, petFound, err := repositories.Pet.Load(ctx, characterID)
|
|
if err != nil {
|
|
s.logGameEvent(session, "game-combat-power-affix-private-projection-deferred",
|
|
"source", source,
|
|
"char_id", session.selectedCharacterID,
|
|
"private_abi", currentCombatPowerAffixPrivateABI,
|
|
"reason", "pet_load_failed",
|
|
"error", err)
|
|
return false, nil
|
|
}
|
|
|
|
itemIDs := combatPowerEquippedItemIDs(
|
|
equipment, equipmentFound, petRecord, petFound, time.Now())
|
|
result, err := catalog.Aggregate(ctx, itemIDs)
|
|
if err != nil {
|
|
s.logGameEvent(session, "game-combat-power-affix-private-projection-deferred",
|
|
"source", source,
|
|
"char_id", session.selectedCharacterID,
|
|
"private_abi", currentCombatPowerAffixPrivateABI,
|
|
"reason", "pvf_affix_aggregate_failed",
|
|
"error", err)
|
|
return false, nil
|
|
}
|
|
missingAttackStats := 0
|
|
for _, itemID := range itemIDs {
|
|
itemStats, found := s.equipmentPVFStat(ctx, itemID, nil)
|
|
if !found {
|
|
missingAttackStats++
|
|
continue
|
|
}
|
|
stats.Add(itemStats)
|
|
}
|
|
level := character.Level
|
|
if level <= 0 {
|
|
level = 1
|
|
}
|
|
if level > math.MaxUint8 {
|
|
level = math.MaxUint8
|
|
}
|
|
body := buildCurrentCombatPowerAffixBody(currentCombatPowerProjection{
|
|
Result: result,
|
|
Job: byte(jobValue),
|
|
GrowType: growType,
|
|
Level: byte(level),
|
|
ProfessionName: professionName,
|
|
Stats: stats,
|
|
CharacterID: uint32(session.selectedCharacterID),
|
|
})
|
|
s.logGameEvent(session, "game-combat-power-affix-private-projection-send",
|
|
"source", source,
|
|
"char_id", session.selectedCharacterID,
|
|
"msg_id", currentCombatPowerAffixMsgID,
|
|
"classification", 0,
|
|
"body_len", len(body),
|
|
"white_tenths", binary.LittleEndian.Uint16(body[2:4]),
|
|
"yellow_tenths", binary.LittleEndian.Uint16(body[4:6]),
|
|
"critical_tenths", binary.LittleEndian.Uint16(body[6:8]),
|
|
"yellow_additional_tenths", binary.LittleEndian.Uint16(body[8:10]),
|
|
"critical_additional_tenths", binary.LittleEndian.Uint16(body[10:12]),
|
|
"all_attack_tenths", binary.LittleEndian.Uint16(body[12:14]),
|
|
"equipped_items", result.EquippedItems,
|
|
"active_sets", len(result.ActiveSets),
|
|
"job", jobValue,
|
|
"grow_type", growType,
|
|
"level", level,
|
|
"profession", professionName,
|
|
"physical_attack", binary.LittleEndian.Uint32(body[22:26]),
|
|
"magical_attack", binary.LittleEndian.Uint32(body[26:30]),
|
|
"independent_attack", binary.LittleEndian.Uint32(body[30:34]),
|
|
"pvf_equipment_score", binary.LittleEndian.Uint32(body[66:70]),
|
|
"character_id", uint32(session.selectedCharacterID),
|
|
"pvf_scored_items", result.ScoredItems,
|
|
"pvf_level90_epic_items", result.Level90EpicItems,
|
|
"missing_item_attack_stats", missingAttackStats,
|
|
"private_abi", currentCombatPowerAffixPrivateABI,
|
|
"wire_owner", "90CN.dll",
|
|
"native_exe_protocol", false)
|
|
if err := s.sendGameUpperRawClass(session, currentCombatPowerAffixMsgID, body, 0); err != nil {
|
|
return false, err
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
func combatPowerEquippedItemIDs(
|
|
equipment dnfrepo.EquipmentRecord,
|
|
equipmentFound bool,
|
|
petRecord dnfrepo.PetRecord,
|
|
petFound bool,
|
|
now time.Time,
|
|
) []int64 {
|
|
itemIDs := make([]int64, 0, len(equipment.Entries)+4)
|
|
occupied := make(map[int16]bool, 33)
|
|
for _, entry := range equipment.Entries {
|
|
if entry.ItemID <= 0 || !combatPowerActorSlot(entry.SlotIndex) ||
|
|
(!entry.ExpireAt.IsZero() && !entry.ExpireAt.After(now)) {
|
|
continue
|
|
}
|
|
occupied[entry.SlotIndex] = true
|
|
itemIDs = append(itemIDs, entry.ItemID)
|
|
}
|
|
|
|
// A present equipment record is authoritative for creature slot 26. Only
|
|
// imported legacy characters with no equipment record may fall back to the
|
|
// durable pet owner's EquippedKey.
|
|
if petFound && !equipmentFound && !occupied[26] {
|
|
if pet, ok := petRecord.Entries[petRecord.EquippedKey]; ok && pet.ItemID > 0 {
|
|
occupied[26] = true
|
|
itemIDs = append(itemIDs, pet.ItemID)
|
|
}
|
|
}
|
|
|
|
// Pet artifacts are owned by PetRecord under semantic color keys instead
|
|
// of historical equipment numbers. Project them into the current actor's
|
|
// three dedicated combat-power slots without double-counting imported rows.
|
|
for index, kind := range []string{"red", "blue", "green"} {
|
|
slot := int16(27 + index)
|
|
if !petFound || occupied[slot] {
|
|
continue
|
|
}
|
|
artifact, ok := petRecord.Artifacts[kind]
|
|
if !ok || artifact.ItemID <= 0 || artifact.Count <= 0 ||
|
|
(!artifact.ExpireAt.IsZero() && !artifact.ExpireAt.After(now)) {
|
|
continue
|
|
}
|
|
occupied[slot] = true
|
|
itemIDs = append(itemIDs, artifact.ItemID)
|
|
}
|
|
sort.Slice(itemIDs, func(i, j int) bool { return itemIDs[i] < itemIDs[j] })
|
|
return itemIDs
|
|
}
|
|
|
|
func combatPowerActorSlot(slot int16) bool {
|
|
// The current EXE owns one 33-slot actor equipment map. Every proved worn
|
|
// slot participates in the PVF affix scan: ordinary equipment, avatars,
|
|
// aura/skin/name-tag/weapon-avatar, creature, three pet artifacts, and
|
|
// guild medal. A slot without a relevant PVF damage entry contributes zero.
|
|
return slot >= 0 && slot <= 32
|
|
}
|