hanfuit
645b64fe21
服务端（Go）： - GM 塞背包/带属性装备发放：在线角色推送 op14 增量物品行，背包实时刷新，无需回角色选择界面 - GM 改金币/改等级：去掉在线拒绝，落库后推送 op14 钱包/op37 等级状态，在线实时刷新 - 等级端点统一切换到新版 GMSetCharacterLevel（自带在线刷新） - 无限/锁死疲劳模式 + 燃烧疲劳：每房间消耗 2 点、打怪与通关经验双倍 - 燃烧疲劳开关时给所有在线角色推送系统提示（op12 mode 0） - 深渊史诗掉率：GM 全局倍率 + 城镇增益药剂窗口倍率，真实接入掉落结算 启动器（Python/JS）： - 标题栏自绘、窗口 1204x717、禁止拖拽改大小、仅最小化/关闭 - GM 工具：疲劳与燃烧、深渊史诗掉率、拍卖行上架（单一定价对齐） - 拍卖行上架前端对齐服务端单一价格语义，修复 400 报错
437 lines
15 KiB
Go
437 lines
15 KiB
Go
package pet
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/binary"
|
|
"errors"
|
|
"sync"
|
|
"testing"
|
|
|
|
"longheng.io/server/internal/modules/dnf/alignedcmd"
|
|
"longheng.io/server/internal/modules/dnf/dnfenum"
|
|
dnfproto "longheng.io/server/internal/modules/dnf/protocol"
|
|
dnfrepo "longheng.io/server/internal/modules/dnf/repository"
|
|
dnfrepomemory "longheng.io/server/internal/modules/dnf/repository/memory"
|
|
)
|
|
|
|
func TestDecodeRenameCreatureRequestExactCurrentBody(t *testing.T) {
|
|
got, err := DecodeRenameCreatureRequest(renameCreatureRequestBody(5, listTypePet, []byte("Mina")))
|
|
if err != nil {
|
|
t.Fatalf("DecodeRenameCreatureRequest: %v", err)
|
|
}
|
|
if got.SlotIndex != 5 || got.ListType != listTypePet || !bytes.Equal(got.NameRaw, []byte("Mina")) {
|
|
t.Fatalf("request = %+v", got)
|
|
}
|
|
// GBK/codepage-encoded names must not be rejected as invalid UTF-8.
|
|
gbkName := []byte{0xc7, 0xbf, 0xd6, 0xc6}
|
|
gotGBK, err := DecodeRenameCreatureRequest(renameCreatureRequestBody(5, listTypePet, gbkName))
|
|
if err != nil || !bytes.Equal(gotGBK.NameRaw, gbkName) {
|
|
t.Fatalf("gbk rename request=%+v err=%v", gotGBK, err)
|
|
}
|
|
// The current-EXE validator rejects an empty name.
|
|
if _, err := DecodeRenameCreatureRequest(renameCreatureRequestBody(0, listTypePet, nil)); err == nil {
|
|
t.Fatalf("empty rename request unexpectedly accepted")
|
|
}
|
|
|
|
tooLong := bytes.Repeat([]byte{'x'}, maxCreatureRenameNameBytes+1)
|
|
declaredShort := renameCreatureRequestBody(5, listTypePet, []byte("abc"))
|
|
binary.LittleEndian.PutUint32(declaredShort[3:7], 2)
|
|
for _, body := range [][]byte{
|
|
{5, 0, listTypePet},
|
|
renameCreatureRequestBody(5, 6, []byte("x")),
|
|
renameCreatureRequestBody(140, listTypePet, []byte("x")),
|
|
renameCreatureRequestBody(5, listTypePet, tooLong),
|
|
renameCreatureRequestBody(5, listTypePet, []byte{'a', 0, 'b'}),
|
|
declaredShort,
|
|
append(renameCreatureRequestBody(5, listTypePet, []byte("x")), 0),
|
|
} {
|
|
if _, err := DecodeRenameCreatureRequest(body); err == nil {
|
|
t.Fatalf("body % X unexpectedly accepted", body)
|
|
}
|
|
}
|
|
// The nine literal characters rejected by the current-EXE validator.
|
|
for _, forbidden := range []byte{'\'', ' ', '\t', '\\', '%', '<', '>', '"', '|'} {
|
|
if _, err := DecodeRenameCreatureRequest(renameCreatureRequestBody(5, listTypePet, []byte{'a', forbidden, 'b'})); err == nil {
|
|
t.Fatalf("name containing %q unexpectedly accepted", forbidden)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestOwnerRenameConsumesCardAndPersistsEquippedCreatureName(t *testing.T) {
|
|
ctx := context.Background()
|
|
repos := dnfrepomemory.NewMemoryGroup()
|
|
seedRenameCreature(t, ctx, repos, "77")
|
|
owner, err := NewOwner(repos)
|
|
if err != nil {
|
|
t.Fatalf("NewOwner: %v", err)
|
|
}
|
|
|
|
command := RenameCommand{SelectedCharacterID: 77, ListType: listTypePet, SlotIndex: 5, NameRaw: []byte("Mina")}
|
|
first, err := owner.Rename(ctx, command)
|
|
if err != nil {
|
|
t.Fatalf("Rename: %v", err)
|
|
}
|
|
if !first.Changed || first.CharacterID != "77" || first.PetKey != "37" || first.CreatureSerial != 37 ||
|
|
first.ItemID != 63000 || first.ListType != listTypePet || first.SourceListType != currentMainInventoryListType ||
|
|
first.SlotIndex != 5 || first.RemainingCount != 1 {
|
|
t.Fatalf("first result = %+v", first)
|
|
}
|
|
record, found, err := repos.Pet.Load(ctx, "77")
|
|
if err != nil || !found {
|
|
t.Fatalf("load pet found=%t err=%v", found, err)
|
|
}
|
|
entry := record.Entries["37"]
|
|
if entry.Name != "Mina" || !bytes.Equal(entry.NameRaw, []byte("Mina")) || entry.Level != 4 || entry.Exp != 12 || entry.Satiety != 80 {
|
|
t.Fatalf("renamed entry = %+v", entry)
|
|
}
|
|
updatedAt := record.UpdatedAt
|
|
inventory, _, _ := repos.Inventory.Load(ctx, "77")
|
|
if stack := inventory.Slots["0:5"]; stack.ItemID != currentPetRenameCardItemID || stack.Count != 1 {
|
|
t.Fatalf("rename card after first use = %+v", stack)
|
|
}
|
|
|
|
second, err := owner.Rename(ctx, command)
|
|
if err != nil {
|
|
t.Fatalf("second Rename: %v", err)
|
|
}
|
|
if second.Changed || second.RemainingCount != 0 {
|
|
t.Fatalf("second result = %+v", second)
|
|
}
|
|
record, _, _ = repos.Pet.Load(ctx, "77")
|
|
if !record.UpdatedAt.Equal(updatedAt) {
|
|
t.Fatalf("same-name use rewrote pet timestamp: before=%v after=%v", updatedAt, record.UpdatedAt)
|
|
}
|
|
inventory, _, _ = repos.Inventory.Load(ctx, "77")
|
|
if _, found := inventory.Slots["0:5"]; found {
|
|
t.Fatalf("exhausted rename card row still exists: %+v", inventory.Slots["0:5"])
|
|
}
|
|
if _, err := owner.Rename(ctx, command); !errors.Is(err, ErrPetRenameCardInvalid) {
|
|
t.Fatalf("third Rename error = %v, want %v", err, ErrPetRenameCardInvalid)
|
|
}
|
|
}
|
|
|
|
func TestOwnerRenameRejectsCardAndEquippedCreatureMismatchWithoutMutation(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
mutate func(*dnfrepo.InventoryRecord, *dnfrepo.EquipmentRecord, *dnfrepo.PetRecord)
|
|
wantErr error
|
|
}{
|
|
{
|
|
name: "wrong card item",
|
|
mutate: func(inventory *dnfrepo.InventoryRecord, _ *dnfrepo.EquipmentRecord, _ *dnfrepo.PetRecord) {
|
|
stack := inventory.Slots["0:5"]
|
|
stack.ItemID++
|
|
inventory.Slots["0:5"] = stack
|
|
},
|
|
wantErr: ErrPetRenameCardInvalid,
|
|
},
|
|
{
|
|
name: "wrong card path",
|
|
mutate: func(inventory *dnfrepo.InventoryRecord, _ *dnfrepo.EquipmentRecord, _ *dnfrepo.PetRecord) {
|
|
stack := inventory.Slots["0:5"]
|
|
stack.Extra["pvf_path"] = "stackable/cash/other.stk"
|
|
inventory.Slots["0:5"] = stack
|
|
},
|
|
wantErr: ErrPetRenameCardInvalid,
|
|
},
|
|
{
|
|
name: "missing equipped slot",
|
|
mutate: func(_ *dnfrepo.InventoryRecord, equipment *dnfrepo.EquipmentRecord, _ *dnfrepo.PetRecord) {
|
|
delete(equipment.Entries, "26")
|
|
},
|
|
wantErr: ErrPetEquippedAbsent,
|
|
},
|
|
{
|
|
name: "missing equipped serial",
|
|
mutate: func(_ *dnfrepo.InventoryRecord, equipment *dnfrepo.EquipmentRecord, _ *dnfrepo.PetRecord) {
|
|
entry := equipment.Entries["26"]
|
|
binary.LittleEndian.PutUint32(entry.RawEntry[24:28], 0)
|
|
equipment.Entries["26"] = entry
|
|
},
|
|
wantErr: ErrPetCreatureSerialAbsent,
|
|
},
|
|
{
|
|
name: "item mismatch",
|
|
mutate: func(_ *dnfrepo.InventoryRecord, _ *dnfrepo.EquipmentRecord, record *dnfrepo.PetRecord) {
|
|
entry := record.Entries["37"]
|
|
entry.ItemID++
|
|
record.Entries["37"] = entry
|
|
},
|
|
wantErr: ErrPetInventoryMismatch,
|
|
},
|
|
{
|
|
name: "entry serial mismatch",
|
|
mutate: func(_ *dnfrepo.InventoryRecord, _ *dnfrepo.EquipmentRecord, record *dnfrepo.PetRecord) {
|
|
entry := record.Entries["37"]
|
|
entry.CreatureKey = 38
|
|
record.Entries["37"] = entry
|
|
},
|
|
wantErr: ErrPetInventoryMismatch,
|
|
},
|
|
{
|
|
name: "equipped key mismatch",
|
|
mutate: func(_ *dnfrepo.InventoryRecord, _ *dnfrepo.EquipmentRecord, record *dnfrepo.PetRecord) {
|
|
record.EquippedKey = "38"
|
|
},
|
|
wantErr: ErrPetInventoryMismatch,
|
|
},
|
|
{
|
|
name: "entry missing",
|
|
mutate: func(_ *dnfrepo.InventoryRecord, _ *dnfrepo.EquipmentRecord, record *dnfrepo.PetRecord) {
|
|
delete(record.Entries, "37")
|
|
},
|
|
wantErr: ErrPetInventoryMismatch,
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
ctx := context.Background()
|
|
repos := dnfrepomemory.NewMemoryGroup()
|
|
seedRenameCreature(t, ctx, repos, "77")
|
|
inventory, _, _ := repos.Inventory.Load(ctx, "77")
|
|
equipment, _, _ := repos.Equipment.Load(ctx, "77")
|
|
record, _, _ := repos.Pet.Load(ctx, "77")
|
|
test.mutate(&inventory, &equipment, &record)
|
|
if err := repos.Inventory.Save(ctx, inventory); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := repos.Equipment.Save(ctx, equipment); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := repos.Pet.Save(ctx, record); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
owner, _ := NewOwner(repos)
|
|
_, err := owner.Rename(ctx, RenameCommand{SelectedCharacterID: 77, ListType: listTypePet, SlotIndex: 5, NameRaw: []byte("new")})
|
|
if !errors.Is(err, test.wantErr) {
|
|
t.Fatalf("Rename error = %v, want %v", err, test.wantErr)
|
|
}
|
|
afterInventory, _, _ := repos.Inventory.Load(ctx, "77")
|
|
if stack := afterInventory.Slots["0:5"]; stack.Count != 2 {
|
|
t.Fatalf("failed rename consumed card: %+v", stack)
|
|
}
|
|
after, _, _ := repos.Pet.Load(ctx, "77")
|
|
if entry, exists := after.Entries["37"]; exists && (entry.Name != "old" || !bytes.Equal(entry.NameRaw, []byte("old"))) {
|
|
t.Fatalf("failed rename mutated entry = %+v", entry)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestHandlerRenameCreatureReturnsAckNativeNameNotificationAndDoesNotSwallowFailure(t *testing.T) {
|
|
ctx := context.Background()
|
|
repos := dnfrepomemory.NewMemoryGroup()
|
|
seedRenameCreature(t, ctx, repos, "77")
|
|
|
|
result, err := NewHandler().Handle(ctx, alignedcmd.Request{
|
|
Opcode: uint16(dnfenum.CmdPacketRenameCreature),
|
|
Body: renameCreatureRequestBody(5, listTypePet, []byte("Mina")),
|
|
AccountID: "account",
|
|
SelectedCharacterID: 77,
|
|
Repositories: repos,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("Handle: %v", err)
|
|
}
|
|
if !result.Handled || !result.ResponseAllowed || result.Operation != "rename_creature" ||
|
|
len(result.UpperResponses) != 2 ||
|
|
len(result.ItemSlotRefreshes) != 1 ||
|
|
result.ItemSlotRefreshes[0] != (alignedcmd.ItemSlotRefresh{ListType: currentMainInventoryListType, SlotIndex: 5}) ||
|
|
len(result.PostActions) != 0 {
|
|
t.Fatalf("result = %+v", result)
|
|
}
|
|
ack := result.UpperResponses[0]
|
|
if ack.MsgID != uint16(dnfenum.CmdPacketRenameCreature) || ack.Classification != dnfproto.DefaultChannelClassification || !ack.AllowCodec || !bytes.Equal(ack.Body, []byte{5, 0, listTypePet}) {
|
|
t.Fatalf("ack = %+v body=% X", ack, ack.Body)
|
|
}
|
|
notify := result.UpperResponses[1]
|
|
wantNotify := []byte{77, 0, 4, 0, 0, 0, 'M', 'i', 'n', 'a'}
|
|
if notify.MsgID != 101 || notify.Classification != 0 || !notify.AllowCodec || !bytes.Equal(notify.Body, wantNotify) {
|
|
t.Fatalf("name notification = %+v body=% X want=% X", notify, notify.Body, wantNotify)
|
|
}
|
|
commitErr := errors.New("rename commit failed")
|
|
failing := repos
|
|
failing.CharacterPets = renameCommitFailureUOW{base: repos, err: commitErr}
|
|
failed, err := NewHandler().Handle(ctx, alignedcmd.Request{
|
|
Opcode: uint16(dnfenum.CmdPacketRenameCreature),
|
|
Body: renameCreatureRequestBody(5, listTypePet, []byte("Other")),
|
|
SelectedCharacterID: 77,
|
|
Repositories: failing,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("failed Handle returned Go error: %v", err)
|
|
}
|
|
if !failed.Handled || failed.ResponseAllowed || len(failed.UpperResponses) != 0 {
|
|
t.Fatalf("commit failure was swallowed: %+v", failed)
|
|
}
|
|
record, _, _ := repos.Pet.Load(ctx, "77")
|
|
if entry := record.Entries["37"]; entry.Name != "Mina" || !bytes.Equal(entry.NameRaw, []byte("Mina")) {
|
|
t.Fatalf("commit failure mutated durable entry = %+v", entry)
|
|
}
|
|
}
|
|
|
|
func TestOwnerRenameConcurrentUseConsumesOneAvailableCardExactlyOnce(t *testing.T) {
|
|
ctx := context.Background()
|
|
repos := dnfrepomemory.NewMemoryGroup()
|
|
seedRenameCreature(t, ctx, repos, "77")
|
|
inventory, _, _ := repos.Inventory.Load(ctx, "77")
|
|
card := inventory.Slots["0:5"]
|
|
card.Count = 1
|
|
inventory.Slots["0:5"] = card
|
|
if err := repos.Inventory.Save(ctx, inventory); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
owner, _ := NewOwner(repos)
|
|
command := RenameCommand{SelectedCharacterID: 77, ListType: listTypePet, SlotIndex: 5, NameRaw: []byte("Mina")}
|
|
|
|
const workers = 32
|
|
results := make(chan RenameResult, workers)
|
|
errorsCh := make(chan error, workers)
|
|
var wait sync.WaitGroup
|
|
for range workers {
|
|
wait.Add(1)
|
|
go func() {
|
|
defer wait.Done()
|
|
result, err := owner.Rename(ctx, command)
|
|
if err != nil {
|
|
errorsCh <- err
|
|
return
|
|
}
|
|
results <- result
|
|
}()
|
|
}
|
|
wait.Wait()
|
|
close(results)
|
|
close(errorsCh)
|
|
failures := 0
|
|
for err := range errorsCh {
|
|
if !errors.Is(err, ErrPetRenameCardInvalid) {
|
|
t.Fatalf("concurrent Rename: %v", err)
|
|
}
|
|
failures++
|
|
}
|
|
changed := 0
|
|
successes := 0
|
|
for result := range results {
|
|
successes++
|
|
if result.Changed {
|
|
changed++
|
|
}
|
|
}
|
|
if successes != 1 || changed != 1 || failures != workers-1 {
|
|
t.Fatalf("successes=%d changed=%d failures=%d, want 1/1/%d", successes, changed, failures, workers-1)
|
|
}
|
|
record, _, _ := repos.Pet.Load(ctx, "77")
|
|
if entry := record.Entries["37"]; entry.Name != "Mina" || !bytes.Equal(entry.NameRaw, []byte("Mina")) {
|
|
t.Fatalf("final entry = %+v", entry)
|
|
}
|
|
inventory, _, _ = repos.Inventory.Load(ctx, "77")
|
|
if _, found := inventory.Slots["0:5"]; found {
|
|
t.Fatalf("consumed card row still exists: %+v", inventory.Slots["0:5"])
|
|
}
|
|
}
|
|
|
|
type renameCommitFailureUOW struct {
|
|
base dnfrepo.Group
|
|
err error
|
|
}
|
|
|
|
func (u renameCommitFailureUOW) WithinCharacterPets(
|
|
ctx context.Context,
|
|
characterID string,
|
|
apply func(dnfrepo.InventoryRepository, dnfrepo.EquipmentRepository, dnfrepo.PetRepository) error,
|
|
) error {
|
|
staged := dnfrepomemory.NewMemoryGroup()
|
|
if record, found, err := u.base.Inventory.Load(ctx, characterID); err != nil {
|
|
return err
|
|
} else if found {
|
|
if err := staged.Inventory.Save(ctx, record); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if record, found, err := u.base.Equipment.Load(ctx, characterID); err != nil {
|
|
return err
|
|
} else if found {
|
|
if err := staged.Equipment.Save(ctx, record); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if record, found, err := u.base.Pet.Load(ctx, characterID); err != nil {
|
|
return err
|
|
} else if found {
|
|
if err := staged.Pet.Save(ctx, record); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if err := apply(staged.Inventory, staged.Equipment, staged.Pet); err != nil {
|
|
return err
|
|
}
|
|
return u.err
|
|
}
|
|
|
|
func seedRenameCreature(t *testing.T, ctx context.Context, repos dnfrepo.Group, characterID string) {
|
|
t.Helper()
|
|
if err := repos.Inventory.Save(ctx, dnfrepo.InventoryRecord{
|
|
CharacterID: characterID,
|
|
Slots: map[string]dnfrepo.ItemStack{
|
|
"0:5": {
|
|
ItemID: currentPetRenameCardItemID,
|
|
Count: 2,
|
|
Extra: map[string]string{
|
|
"item_kind": "stackable",
|
|
"pvf_path": currentPetRenameCardPVFPath,
|
|
"stackable_type": "[creature]",
|
|
},
|
|
},
|
|
},
|
|
}); err != nil {
|
|
t.Fatalf("save inventory: %v", err)
|
|
}
|
|
rawEquipment := make([]byte, 0x77)
|
|
binary.LittleEndian.PutUint32(rawEquipment[24:28], 37)
|
|
if err := repos.Equipment.Save(ctx, dnfrepo.EquipmentRecord{
|
|
CharacterID: characterID,
|
|
Entries: map[string]dnfrepo.EquipmentEntry{
|
|
"26": {
|
|
SlotIndex: currentEquippedCreatureSlot,
|
|
ItemID: 63000,
|
|
RawEntry: rawEquipment,
|
|
},
|
|
},
|
|
}); err != nil {
|
|
t.Fatalf("save equipment: %v", err)
|
|
}
|
|
if err := repos.Pet.Save(ctx, dnfrepo.PetRecord{
|
|
CharacterID: characterID,
|
|
Entries: map[string]dnfrepo.PetEntry{
|
|
"37": {
|
|
PetKey: "37",
|
|
CreatureKey: 37,
|
|
ItemID: 63000,
|
|
SourceListType: listTypePet,
|
|
SourceSlotIndex: 5,
|
|
Name: "old",
|
|
NameRaw: []byte("old"),
|
|
Satiety: 80,
|
|
Level: 4,
|
|
Exp: 12,
|
|
},
|
|
},
|
|
EquippedKey: "37",
|
|
}); err != nil {
|
|
t.Fatalf("save pet: %v", err)
|
|
}
|
|
}
|
|
|
|
func renameCreatureRequestBody(slot int16, listType byte, name []byte) []byte {
|
|
body := make([]byte, 7+len(name))
|
|
binary.LittleEndian.PutUint16(body[0:2], uint16(slot))
|
|
body[2] = listType
|
|
binary.LittleEndian.PutUint32(body[3:7], uint32(len(name)))
|
|
copy(body[7:], name)
|
|
return body
|
|
}
|