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 2026-11-04 14:31:55 +08:00
commit 645b64fe21
4388 files changed
+1405457

No files matched your search

+262
View File
@@ -0,0 +1,262 @@
package pet
import (
"bytes"
"context"
"encoding/binary"
"errors"
"fmt"
"strconv"
"strings"
"time"
"golang.org/x/text/encoding/simplifiedchinese"
dnfrepo "longheng.io/server/internal/modules/dnf/repository"
)
const (
currentPetRenameCardItemID int64 = 25
currentPetRenameCardPVFPath = "stackable/cash/creature/rename_card.stk"
currentEquippedCreatureSlot = 26
currentMainInventoryListType byte = 0
)
var (
ErrPetRecordNotFound = errors.New("pet record not found")
ErrPetRenameNameInvalid = errors.New("pet rename name is invalid")
ErrPetRenameCardInvalid = errors.New("pet rename card is invalid")
ErrPetInventoryMismatch = errors.New("pet inventory and creature record are inconsistent")
ErrPetRecordOwnerMismatch = errors.New("pet aggregate owner does not match selected character")
ErrPetCreatureSerialAbsent = errors.New("pet inventory serial is absent")
ErrPetEquippedAbsent = errors.New("equipped pet creature is absent")
)
// RenameCommand identifies the pet-panel rename-card slot and carries the
// current EXE's fixed creature semantic value in ListType. Item and creature
// identity are deliberately absent: both are loaded from durable state.
type RenameCommand struct {
SelectedCharacterID uint16
ListType byte
SlotIndex int16
NameRaw []byte
}
// RenameResult contains only committed identity and the proved ACK fields.
type RenameResult struct {
CharacterID string
PetKey string
CreatureSerial uint32
ItemID int64
ListType byte
SourceListType byte
SlotIndex int16
NameRaw []byte
RemainingCount int64
Changed bool
}
// Rename validates and consumes the exact current-PVF rename card from either
// the legacy main inventory or the pet-panel consumable range, then renames
// the creature installed in equipment slot 26 in one character-scoped
// transaction. Current EXE sub_31F5220 sends the card slot, a fixed creature
// semantic value 7 and the new DSTR; the slot range identifies the source
// container. Its op100 success handler consumes the echoed source row by one.
func (o *Owner) Rename(ctx context.Context, cmd RenameCommand) (RenameResult, error) {
if o == nil || o.pets == nil {
return RenameResult{}, ErrPetOwnerUnavailable
}
if o.characterPets == nil {
return RenameResult{}, ErrPetTransactionUnavailable
}
if cmd.SelectedCharacterID == 0 {
return RenameResult{}, ErrCharacterRequired
}
if cmd.ListType != listTypePet {
return RenameResult{}, fmt.Errorf("%w: %d", ErrUnsupportedList, cmd.ListType)
}
if cmd.SlotIndex < 0 || (cmd.SlotIndex > 139 && (cmd.SlotIndex < 189 || cmd.SlotIndex > 238)) {
return RenameResult{}, fmt.Errorf("%w: list=%d slot=%d", ErrSlotNotFound, cmd.ListType, cmd.SlotIndex)
}
if err := validateCreatureRenameName(cmd.NameRaw); err != nil {
return RenameResult{}, fmt.Errorf("%w: %v", ErrPetRenameNameInvalid, err)
}
characterID := strconv.FormatUint(uint64(cmd.SelectedCharacterID), 10)
var committed RenameResult
err := o.characterPets.WithinCharacterPets(ctx, characterID, func(
inventoryRepo dnfrepo.InventoryRepository,
equipmentRepo dnfrepo.EquipmentRepository,
petRepo dnfrepo.PetRepository,
) error {
inventory, found, err := inventoryRepo.Load(ctx, characterID)
if err != nil {
return err
}
if !found {
return ErrInventoryNotFound
}
if strings.TrimSpace(inventory.CharacterID) != characterID {
return fmt.Errorf("%w: inventory=%q selected=%q", ErrPetRecordOwnerMismatch, inventory.CharacterID, characterID)
}
inventory = dnfrepo.CloneInventory(inventory)
// Current EXE sub_31F5220 always writes semantic creature value 7
// after the rename-card slot. The slot itself is a main-inventory
// index; 7 is not the durable source collection. Slots 189..238 are
// the pet-panel consumable range; older characters may still have the
// card in list 0.
sourceListType := currentMainInventoryListType
if cmd.SlotIndex >= 189 && cmd.SlotIndex <= 238 {
sourceListType = listTypePet
}
cardSlot := slotKey(sourceListType, cmd.SlotIndex)
card, found := inventory.Slots[cardSlot]
if !found || card.Count <= 0 {
return fmt.Errorf("%w: list=%d slot=%d", ErrPetRenameCardInvalid, cmd.ListType, cmd.SlotIndex)
}
if !isCurrentPetRenameCard(card) {
return fmt.Errorf(
"%w: list=%d slot=%d item=%d path=%q type=%q",
ErrPetRenameCardInvalid,
cmd.ListType,
cmd.SlotIndex,
card.ItemID,
card.Extra["pvf_path"],
card.Extra["stackable_type"],
)
}
equipment, found, err := equipmentRepo.Load(ctx, characterID)
if err != nil {
return err
}
if !found {
return ErrPetEquippedAbsent
}
if strings.TrimSpace(equipment.CharacterID) != characterID {
return fmt.Errorf("%w: equipment=%q selected=%q", ErrPetRecordOwnerMismatch, equipment.CharacterID, characterID)
}
equippedItemID, equippedSerial, err := equippedCreatureIdentity(equipment)
if err != nil {
return err
}
petRecord, found, err := petRepo.Load(ctx, characterID)
if err != nil {
return err
}
if !found {
return ErrPetRecordNotFound
}
if strings.TrimSpace(petRecord.CharacterID) != characterID {
return fmt.Errorf("%w: pet=%q selected=%q", ErrPetRecordOwnerMismatch, petRecord.CharacterID, characterID)
}
petRecord = dnfrepo.ClonePet(petRecord)
if _, err := validatedCreatureEntries(petRecord); err != nil {
return err
}
petKey := strconv.FormatUint(uint64(equippedSerial), 10)
entry, found := petRecord.Entries[petKey]
if !found {
return fmt.Errorf("%w: serial=%d has no PetRecord entry", ErrPetInventoryMismatch, equippedSerial)
}
if entry.PetKey != petKey || entry.CreatureKey != equippedSerial || entry.ItemID != equippedItemID {
return fmt.Errorf(
"%w: equipped_item=%d serial=%d entry_key=%q entry_serial=%d entry_item=%d",
ErrPetInventoryMismatch,
equippedItemID,
equippedSerial,
entry.PetKey,
entry.CreatureKey,
entry.ItemID,
)
}
if equippedKey := strings.TrimSpace(petRecord.EquippedKey); equippedKey != petKey {
return fmt.Errorf("%w: equipment_serial=%d equipped_key=%q", ErrPetInventoryMismatch, equippedSerial, equippedKey)
}
currentName := entry.NameRaw
if len(currentName) == 0 && entry.Name != "" {
currentName = []byte(entry.Name)
}
changed := !bytes.Equal(currentName, cmd.NameRaw)
if changed {
entry.NameRaw = append([]byte(nil), cmd.NameRaw...)
entry.Name = decodeCurrentCreatureName(cmd.NameRaw)
petRecord.Entries[petKey] = entry
petRecord.UpdatedAt = time.Now()
}
remaining := card.Count - 1
if remaining == 0 {
delete(inventory.Slots, cardSlot)
} else {
card.Count = remaining
inventory.Slots[cardSlot] = card
}
inventory.UpdatedAt = time.Now()
if err := dnfrepo.SaveInventoryFields(ctx, inventoryRepo, inventory, dnfrepo.InventoryFieldSlots); err != nil {
return err
}
if changed {
if err := dnfrepo.SavePetFields(ctx, petRepo, petRecord, dnfrepo.PetFieldEntries); err != nil {
return err
}
}
committed = RenameResult{
CharacterID: characterID,
PetKey: petKey,
CreatureSerial: equippedSerial,
ItemID: equippedItemID,
ListType: cmd.ListType,
SourceListType: sourceListType,
SlotIndex: cmd.SlotIndex,
NameRaw: append([]byte(nil), cmd.NameRaw...),
RemainingCount: remaining,
Changed: changed,
}
return nil
})
if err != nil {
return RenameResult{}, err
}
return committed, nil
}
func isCurrentPetRenameCard(stack dnfrepo.ItemStack) bool {
if stack.ItemID != currentPetRenameCardItemID || stack.Count <= 0 || stack.Extra == nil {
return false
}
path := strings.ToLower(strings.ReplaceAll(strings.TrimSpace(stack.Extra["pvf_path"]), "\\", "/"))
stackableType := strings.ToLower(strings.TrimSpace(stack.Extra["stackable_type"]))
return path == currentPetRenameCardPVFPath && strings.Contains(stackableType, "[creature]")
}
func equippedCreatureIdentity(record dnfrepo.EquipmentRecord) (int64, uint32, error) {
entry, found := record.Entries[strconv.Itoa(currentEquippedCreatureSlot)]
if !found || entry.SlotIndex != currentEquippedCreatureSlot || entry.ItemID <= 0 {
for _, candidate := range record.Entries {
if candidate.SlotIndex == currentEquippedCreatureSlot && candidate.ItemID > 0 {
entry = candidate
found = true
break
}
}
}
if !found || len(entry.RawEntry) < 28 {
return 0, 0, ErrPetEquippedAbsent
}
serial := binary.LittleEndian.Uint32(entry.RawEntry[24:28])
if serial == 0 || serial > maxCreatureSerial {
return 0, 0, fmt.Errorf("%w: equipped serial=%d", ErrPetCreatureSerialAbsent, serial)
}
return entry.ItemID, serial, nil
}
func decodeCurrentCreatureName(raw []byte) string {
decoded, err := simplifiedchinese.GB18030.NewDecoder().Bytes(raw)
if err != nil {
return ""
}
return string(decoded)
}