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

@@ -0,0 +1,365 @@
package dnfbridge
import (
"bytes"
"context"
"encoding/binary"
"testing"
"time"
dnfpet "longheng.io/server/internal/modules/dnf/pet"
dnfrepo "longheng.io/server/internal/modules/dnf/repository"
)
func TestCurrentEquippedCreatureProjectsSameRealStateAcrossOp2Modes(t *testing.T) {
const (
characterID = "77"
itemID = uint32(0x17e69f80)
serialOrHandle = uint32(37)
creatureLevel = byte(11)
)
repos := testRepositoryGroup()
raw := testCurrentEquippedCreatureRaw(26, itemID, serialOrHandle)
if err := repos.Equipment.Save(context.Background(), dnfrepo.EquipmentRecord{
CharacterID: characterID,
Entries: map[string]dnfrepo.EquipmentEntry{
"26": {SlotIndex: 26, ItemID: int64(itemID), RawEntry: raw},
},
UpdatedAt: time.Now().UTC(),
}); err != nil {
t.Fatalf("save equipment: %v", err)
}
if err := repos.Pet.Save(context.Background(), dnfrepo.PetRecord{
CharacterID: characterID,
Entries: map[string]dnfrepo.PetEntry{
"pet-37": {
PetKey: "pet-37",
ItemID: int64(itemID),
Name: "petty",
Level: int64(creatureLevel),
Extra: map[string]string{"creature_serial_or_handle": "37"},
},
},
EquippedKey: "pet-37",
TownDisplay: true,
UpdatedAt: time.Now().UTC(),
}); err != nil {
t.Fatalf("save pet: %v", err)
}
service := Service{
repositoryProvider: func() (dnfrepo.Group, bool) { return repos, true },
characterStats: testCharacterStatTable(t),
}
character := dnfrepo.CharacterRecord{
CharacterID: characterID,
Name: "hero",
Job: "11",
Level: 90,
Stats: defaultCreatedCharacterStats(0),
}
snapshot := service.currentEquippedCreatureForCharacter(context.Background(), characterID)
if !snapshot.valid() || snapshot.itemID != itemID || snapshot.serialOrHandle != serialOrHandle ||
snapshot.name != "petty" || snapshot.level != creatureLevel || snapshot.aliveState != 1 ||
!snapshot.townDisplay || snapshot.source != "equipment_slot26_raw" {
t.Fatalf("equipped creature snapshot = %+v", snapshot)
}
mode0 := buildCurrentSceneObjectListBodyWithCreature(77, character, true, character.Name, snapshot)
mode0ItemID, mode0Name, mode0Alive := currentMode0CreatureForTest(t, mode0)
if mode0ItemID != itemID || !bytes.Equal(mode0Name, rosterNameBytes("petty")) || mode0Alive != 1 {
t.Fatalf("mode0 creature item=%#x name=%x alive=%d body=%x", mode0ItemID, mode0Name, mode0Alive, mode0)
}
mode1 := service.buildCurrentSelectedUserInfoMode1Body(context.Background(), nil, nil, character, true, 77)
if got := mode1[currentMode1CreateCountOffset]; got != 0 {
t.Fatalf("slot26 must not enter normal equipment create list: count=%d body=%x", got, mode1)
}
mode1RawOffset := currentMode1CreateRowsOffset + 4 + 2 + 1
assertCurrentCreatureRawForTest(t, "mode1", mode1, mode1RawOffset, itemID, serialOrHandle, creatureLevel)
mode3 := service.buildCurrentSelectedUserInfoMode3Body(context.Background(), nil, nil, character, true, 77)
mode3TailOffset := 0x17 + int(binary.LittleEndian.Uint32(mode3[0x13:0x17]))
if !bytes.Equal(
mode1[currentMode1StatDataOffset:currentMode1ObjectTailOffset],
mode3[0x17:mode3TailOffset],
) {
t.Fatalf("mode1/mode3 actor state differs: mode1=%x mode3=%x", mode1[currentMode1StatDataOffset:currentMode1ObjectTailOffset], mode3[0x17:mode3TailOffset])
}
if got := mode3[mode3TailOffset+1]; got != 0 {
t.Fatalf("slot26 must not enter mode3 normal equipment create list: count=%d body=%x", got, mode3)
}
mode3RawOffset := mode3TailOffset + 2 + 4
assertCurrentCreatureRawForTest(t, "mode3", mode3, mode3RawOffset, itemID, serialOrHandle, creatureLevel)
}
func TestCurrentMode1EquippedCreatureRestoresInstanceAndEnchant(t *testing.T) {
const (
characterID = "77"
itemID = uint32(400990168)
serial = uint32(41)
cardID = uint32(10008705)
upgrade = byte(3)
)
repos := testRepositoryGroup()
raw := testCurrentEquippedCreatureRaw(26, itemID, serial)
binary.LittleEndian.PutUint32(raw[0x10:0x14], cardID)
raw[0x14] = upgrade
if err := repos.Equipment.Save(context.Background(), dnfrepo.EquipmentRecord{
CharacterID: characterID,
Entries: map[string]dnfrepo.EquipmentEntry{
"26": {
SlotIndex: 26,
ItemID: int64(itemID),
RawEntry: raw,
Extra: map[string]string{
"equipment_slot": "26",
"equipped_slot": "26",
"creature_serial_or_handle": "41",
"value_a": "10008705",
"byte_12": "3",
},
},
},
}); err != nil {
t.Fatal(err)
}
service := &Service{repositoryProvider: func() (dnfrepo.Group, bool) { return repos, true }}
reader := csharpLegacyUserInfoReader{
ctx: context.Background(),
characterID: characterID,
service: service,
}
rows := currentMode1EquipmentCreateRows(reader.currentMode1EquipmentObjectRows())
if len(rows) != 1 {
t.Fatalf("mode1 creature create rows=%+v", rows)
}
row := rows[0]
if row.slot != 26 || row.itemID != itemID || row.instance != serial || row.auxValue != cardID || row.auxByte != upgrade {
t.Fatalf("mode1 creature row=%+v", row)
}
var writer packetWriter
writeCurrentMode1EquipmentCreateRow(&writer, row)
wire := writer.bytes()
if len(wire) < 21 || wire[0] != 26 ||
binary.LittleEndian.Uint32(wire[1:5]) != itemID ||
binary.LittleEndian.Uint32(wire[5:9]) != serial ||
binary.LittleEndian.Uint32(wire[16:20]) != cardID ||
wire[20] != upgrade {
t.Fatalf("mode1 creature wire=%x", wire)
}
}
func TestCurrentMode1EquippedCreatureUsesTypedPetEnchantWhenEquipmentAliasIsZero(t *testing.T) {
const characterID = "79"
const itemID uint32 = 400990167
const serial uint32 = 41
const cardID uint32 = 10008729
repos := testRepositoryGroup()
if err := repos.Equipment.Save(context.Background(), dnfrepo.EquipmentRecord{
CharacterID: characterID,
Entries: map[string]dnfrepo.EquipmentEntry{
"26": {
SlotIndex: 26,
ItemID: int64(itemID),
RawEntry: testCurrentEquippedCreatureRaw(26, itemID, serial),
Extra: map[string]string{
"equipment_slot": "26",
"equipped_slot": "26",
"creature_serial_or_handle": "41",
"pet_enchant_card_item_id": "0",
"enchant_card_id": "0",
},
},
},
}); err != nil {
t.Fatal(err)
}
if err := repos.Pet.Save(context.Background(), dnfrepo.PetRecord{
CharacterID: characterID,
Entries: map[string]dnfrepo.PetEntry{
"41": {
PetKey: "41",
CreatureKey: serial,
ItemID: int64(itemID),
Extra: map[string]string{"pet_enchant_card_item_id": "10008729"},
},
},
}); err != nil {
t.Fatal(err)
}
service := &Service{repositoryProvider: func() (dnfrepo.Group, bool) { return repos, true }}
reader := csharpLegacyUserInfoReader{ctx: context.Background(), characterID: characterID, service: service}
rows := currentMode1EquipmentCreateRows(reader.currentMode1EquipmentObjectRows())
if len(rows) != 1 || rows[0].auxValue != cardID {
t.Fatalf("mode1 typed pet enchant rows=%+v", rows)
}
}
func TestCurrentEquippedCreatureProjectsPVFNameIntoMode0WithoutPersistingFallback(t *testing.T) {
const characterID = "78"
repos := testRepositoryGroup()
if err := repos.Equipment.Save(context.Background(), dnfrepo.EquipmentRecord{
CharacterID: characterID,
Entries: map[string]dnfrepo.EquipmentEntry{
"26": {
SlotIndex: 26,
ItemID: 63000,
RawEntry: testCurrentEquippedCreatureRaw(26, 63000, 37),
},
},
}); err != nil {
t.Fatal(err)
}
if err := repos.Pet.Save(context.Background(), dnfrepo.PetRecord{
CharacterID: characterID,
Entries: map[string]dnfrepo.PetEntry{
"37": {
PetKey: "37",
CreatureKey: 37,
ItemID: 63000,
Level: 1,
Satiety: 100,
},
},
EquippedKey: "37",
TownDisplay: true,
}); err != nil {
t.Fatal(err)
}
catalog, err := dnfpet.NewPVFCatalog(bridgePetCatalogFixture())
if err != nil {
t.Fatal(err)
}
service := Service{
repositoryProvider: func() (dnfrepo.Group, bool) { return repos, true },
petCatalog: catalog,
}
snapshot := service.currentEquippedCreatureForCharacter(context.Background(), characterID)
if !snapshot.valid() || snapshot.name != "跳舞的汪" {
t.Fatalf("PVF-enriched snapshot = %+v", snapshot)
}
body := buildCurrentSceneObjectListBodyWithCreature(78, dnfrepo.CharacterRecord{
CharacterID: characterID,
Name: "hero",
Job: "11",
Level: 90,
}, true, "hero", snapshot)
itemID, name, alive := currentMode0CreatureForTest(t, body)
wantName := []byte{0xCC, 0xF8, 0xCE, 0xE8, 0xB5, 0xC4, 0xCD, 0xF4}
if itemID != 63000 || !bytes.Equal(name, wantName) || alive != 1 {
t.Fatalf("mode0 fallback item=%d name=% X alive=%d", itemID, name, alive)
}
record, found, err := repos.Pet.Load(context.Background(), characterID)
if err != nil || !found {
t.Fatalf("load pet found=%t err=%v", found, err)
}
if entry := record.Entries["37"]; entry.Name != "" || len(entry.NameRaw) != 0 {
t.Fatalf("PVF fallback leaked into durable record: %+v", entry)
}
}
func TestCurrentEquippedCreatureDoesNotResurrectStalePetAfterUnequip(t *testing.T) {
repos := testRepositoryGroup()
if err := repos.Equipment.Save(context.Background(), dnfrepo.EquipmentRecord{
CharacterID: "88",
Entries: map[string]dnfrepo.EquipmentEntry{},
}); err != nil {
t.Fatalf("save empty equipment: %v", err)
}
if err := repos.Pet.Save(context.Background(), dnfrepo.PetRecord{
CharacterID: "88",
Entries: map[string]dnfrepo.PetEntry{
"pet-37": {
PetKey: "pet-37",
ItemID: 0x17e69f80,
Name: "stale",
Level: 9,
Extra: map[string]string{"creature_serial_or_handle": "37"},
},
},
EquippedKey: "pet-37",
TownDisplay: true,
}); err != nil {
t.Fatalf("save stale pet record: %v", err)
}
service := Service{repositoryProvider: func() (dnfrepo.Group, bool) { return repos, true }}
snapshot := service.currentEquippedCreatureForCharacter(context.Background(), "88")
if snapshot.valid() || snapshot.itemID != 0 || snapshot.serialOrHandle != 0 || snapshot.source != "equipment_slot26_absent" {
t.Fatalf("stale equipped creature was resurrected: %+v", snapshot)
}
}
func TestCurrentEquippedCreatureDoesNotTreatOrdinarySlot26InstanceAsPet(t *testing.T) {
repos := testRepositoryGroup()
if err := repos.Equipment.Save(context.Background(), dnfrepo.EquipmentRecord{
CharacterID: "99",
Entries: map[string]dnfrepo.EquipmentEntry{
"26": {
SlotIndex: 26,
ItemID: 900024,
RawEntry: buildInitialEquipmentRawEntry(26, 900024, 20),
Extra: map[string]string{"source": "pvf_create_equipment_list", "instance_value": "1"},
},
},
}); err != nil {
t.Fatalf("save ordinary slot26 item: %v", err)
}
service := Service{repositoryProvider: func() (dnfrepo.Group, bool) { return repos, true }}
snapshot := service.currentEquippedCreatureForCharacter(context.Background(), "99")
if snapshot.valid() || snapshot.itemID != 0 || snapshot.serialOrHandle != 0 || snapshot.source != "equipment_slot26_invalid_item_or_serial" {
t.Fatalf("ordinary slot26 item was projected as creature: %+v", snapshot)
}
}
func testCurrentEquippedCreatureRaw(slot byte, itemID uint32, serialOrHandle uint32) []byte {
raw := make([]byte, 50)
raw[0] = slot
binary.LittleEndian.PutUint32(raw[1:5], itemID)
binary.LittleEndian.PutUint32(raw[5:9], serialOrHandle)
binary.LittleEndian.PutUint32(raw[24:28], serialOrHandle)
return raw
}
func currentMode0CreatureForTest(t *testing.T, body []byte) (uint32, []byte, byte) {
t.Helper()
_, tailStart, ok := currentSceneObjectLevelForLog(body)
if !ok {
t.Fatalf("mode0 tail not found: %x", body)
}
equipEnd, ok := currentSceneObjectEquipSummaryEnd(body[tailStart:], 6)
if !ok {
t.Fatalf("mode0 equipment boundary not found: %x", body)
}
offset := tailStart + equipEnd + 22
if offset+8 > len(body) {
t.Fatalf("mode0 creature header truncated at %d/%d", offset, len(body))
}
itemID := binary.LittleEndian.Uint32(body[offset : offset+4])
nameLen := int(binary.LittleEndian.Uint32(body[offset+4 : offset+8]))
nameStart := offset + 8
nameEnd := nameStart + nameLen
if nameLen < 0 || nameEnd >= len(body) {
t.Fatalf("mode0 creature name truncated len=%d at %d/%d", nameLen, offset, len(body))
}
return itemID, append([]byte(nil), body[nameStart:nameEnd]...), body[nameEnd]
}
func assertCurrentCreatureRawForTest(t *testing.T, mode string, body []byte, rawOffset int, itemID uint32, serialOrHandle uint32, level byte) {
t.Helper()
if rawOffset < 0 || rawOffset+12 > len(body) {
t.Fatalf("%s creature raw truncated at %d/%d body=%x", mode, rawOffset, len(body), body)
}
if got := binary.LittleEndian.Uint32(body[rawOffset : rawOffset+4]); got != itemID {
t.Fatalf("%s creature item id=%#x want=%#x body=%x", mode, got, itemID, body)
}
if got := binary.LittleEndian.Uint32(body[rawOffset+4 : rawOffset+8]); got != serialOrHandle {
t.Fatalf("%s creature serial/handle=%d want=%d body=%x", mode, got, serialOrHandle, body)
}
if got := body[rawOffset+8+3]; got != level {
t.Fatalf("%s creature level=%d want=%d body=%x", mode, got, level, body)
}
}