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
commit
645b64fe21
4388 files changed
+1405457
No files matched your search
@@ -0,0 +1,404 @@
|
||||
package dnfbridge
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"fmt"
|
||||
"math"
|
||||
"sort"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"longheng.io/server/internal/modules/dnf/dnfenum"
|
||||
dnfdungeon "longheng.io/server/internal/modules/dnf/dungeon"
|
||||
dnfepicbook "longheng.io/server/internal/modules/dnf/epicbook"
|
||||
dnfrepo "longheng.io/server/internal/modules/dnf/repository"
|
||||
)
|
||||
|
||||
const (
|
||||
// Current 90CN NoPack.exe registers the Epic Book balance handler on wire
|
||||
// 1149. The enum label at this value is stale and must not select the wire.
|
||||
currentEpicBookInfoWireOpcode uint16 = 1149
|
||||
currentEpicBookMakeItemSize = 4
|
||||
currentEpicBookErrorInventory byte = 4
|
||||
currentEpicBookErrorCondition byte = 22
|
||||
)
|
||||
|
||||
var (
|
||||
errCurrentEpicBookUnavailable = errors.New("dnf epic book is unavailable")
|
||||
errCurrentEpicBookRequestInvalid = errors.New("dnf epic book request is invalid")
|
||||
errCurrentEpicBookCondition = errors.New("dnf epic book crafting condition is not met")
|
||||
errCurrentEpicBookBalanceOverflow = errors.New("dnf epic book balance overflow")
|
||||
errCurrentEpicBookInventoryUnavailable = errors.New("dnf epic book inventory is unavailable")
|
||||
)
|
||||
|
||||
type currentEpicBookBalanceRow struct {
|
||||
FragmentID uint32
|
||||
Balance uint32
|
||||
}
|
||||
|
||||
type currentEpicBookCraftResult struct {
|
||||
FragmentID uint32
|
||||
FragmentBalance uint32
|
||||
ItemUpdates []currentItemListEntry
|
||||
}
|
||||
|
||||
func buildCurrentEpicBookInfoBody(mode byte, rows []currentEpicBookBalanceRow) ([]byte, error) {
|
||||
if mode > 1 {
|
||||
return nil, fmt.Errorf("%w: sync mode=%d", errCurrentEpicBookRequestInvalid, mode)
|
||||
}
|
||||
normalized := make(map[uint32]uint32, len(rows))
|
||||
for _, row := range rows {
|
||||
if row.FragmentID == 0 {
|
||||
return nil, fmt.Errorf("%w: fragment id is zero", errCurrentEpicBookRequestInvalid)
|
||||
}
|
||||
normalized[row.FragmentID] = row.Balance
|
||||
}
|
||||
ids := make([]uint32, 0, len(normalized))
|
||||
for fragmentID := range normalized {
|
||||
ids = append(ids, fragmentID)
|
||||
}
|
||||
sort.Slice(ids, func(i, j int) bool { return ids[i] < ids[j] })
|
||||
if uint64(len(ids)) > uint64(math.MaxUint32) {
|
||||
return nil, errCurrentEpicBookBalanceOverflow
|
||||
}
|
||||
var writer packetWriter
|
||||
writer.writeByte(mode)
|
||||
writer.writeUint32(uint32(len(ids)))
|
||||
for _, fragmentID := range ids {
|
||||
writer.writeUint32(fragmentID)
|
||||
writer.writeUint32(normalized[fragmentID])
|
||||
}
|
||||
return writer.bytes(), nil
|
||||
}
|
||||
|
||||
func decodeCurrentEpicBookMakeItemRequest(body []byte) (uint32, error) {
|
||||
if len(body) != currentEpicBookMakeItemSize {
|
||||
return 0, fmt.Errorf("%w: body_len=%d", errCurrentEpicBookRequestInvalid, len(body))
|
||||
}
|
||||
equipmentID := binary.LittleEndian.Uint32(body)
|
||||
if equipmentID == 0 {
|
||||
return 0, fmt.Errorf("%w: equipment id is zero", errCurrentEpicBookRequestInvalid)
|
||||
}
|
||||
return equipmentID, nil
|
||||
}
|
||||
|
||||
func buildCurrentEpicBookMakeItemResult(success bool, errorCode byte) []byte {
|
||||
if success {
|
||||
return []byte{1}
|
||||
}
|
||||
return []byte{0, errorCode}
|
||||
}
|
||||
|
||||
func (s *Service) currentEpicBookCatalog() (*dnfepicbook.Catalog, error) {
|
||||
if s == nil {
|
||||
return nil, errCurrentEpicBookUnavailable
|
||||
}
|
||||
s.epicBookMu.Lock()
|
||||
defer s.epicBookMu.Unlock()
|
||||
if s.epicBookCatalog != nil || s.epicBookCatalogLoadErr != nil {
|
||||
return s.epicBookCatalog, s.epicBookCatalogLoadErr
|
||||
}
|
||||
s.initialEquipmentMu.Lock()
|
||||
archive, err := s.initialEquipmentArchiveLocked()
|
||||
s.initialEquipmentMu.Unlock()
|
||||
if err == nil {
|
||||
var text string
|
||||
text, err = archive.ReadText(dnfepicbook.PieceInfoPath)
|
||||
if err == nil {
|
||||
s.epicBookCatalog, err = dnfepicbook.Parse(text)
|
||||
}
|
||||
}
|
||||
s.epicBookCatalogLoadErr = err
|
||||
return s.epicBookCatalog, s.epicBookCatalogLoadErr
|
||||
}
|
||||
|
||||
func (s *Service) currentEpicBookCatalogIfLoaded() (*dnfepicbook.Catalog, bool, error) {
|
||||
if s == nil {
|
||||
return nil, false, errCurrentEpicBookUnavailable
|
||||
}
|
||||
s.epicBookMu.Lock()
|
||||
defer s.epicBookMu.Unlock()
|
||||
if s.epicBookCatalog != nil {
|
||||
return s.epicBookCatalog, true, nil
|
||||
}
|
||||
if s.epicBookCatalogLoadErr != nil {
|
||||
return nil, true, s.epicBookCatalogLoadErr
|
||||
}
|
||||
return nil, false, nil
|
||||
}
|
||||
|
||||
func (s *Service) preloadEpicBookCatalog(ctx context.Context) error {
|
||||
if s == nil {
|
||||
return nil
|
||||
}
|
||||
if ctx == nil {
|
||||
ctx = context.Background()
|
||||
}
|
||||
if err := ctx.Err(); err != nil {
|
||||
return err
|
||||
}
|
||||
started := time.Now()
|
||||
catalog, err := s.currentEpicBookCatalog()
|
||||
if err != nil {
|
||||
return fmt.Errorf("preload current epic book catalog: %w", err)
|
||||
}
|
||||
s.logPacketEvent("dnf-epic-book-catalog-loaded", "entries", catalog.Len(), "elapsed_ms", time.Since(started).Milliseconds())
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Service) sendCurrentEpicBookSnapshot(session *gameSession, source string) error {
|
||||
if s == nil || session == nil || session.selectedCharacterID == 0 {
|
||||
return nil
|
||||
}
|
||||
if session.selectedEpicBookBootstrapCharacterID == session.selectedCharacterID {
|
||||
return nil
|
||||
}
|
||||
catalog, loaded, err := s.currentEpicBookCatalogIfLoaded()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if !loaded {
|
||||
return nil
|
||||
}
|
||||
repositories, ok := s.repositoryGroup()
|
||||
if !ok || repositories.EpicBook == nil {
|
||||
return errCurrentEpicBookUnavailable
|
||||
}
|
||||
accountID := strings.TrimSpace(s.accountIDForSession(session))
|
||||
ctx, cancel := context.WithTimeout(context.Background(), currentRepositorySnapshotTimeout)
|
||||
defer cancel()
|
||||
record, found, err := repositories.EpicBook.Load(ctx, accountID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rows := make([]currentEpicBookBalanceRow, 0)
|
||||
if found {
|
||||
for equipmentID, balance := range record.Balances {
|
||||
entry, mapped := catalog.EntryByEquipment(equipmentID)
|
||||
if !mapped || balance == 0 {
|
||||
continue
|
||||
}
|
||||
rows = append(rows, currentEpicBookBalanceRow{FragmentID: entry.FragmentID, Balance: balance})
|
||||
}
|
||||
}
|
||||
body, err := buildCurrentEpicBookInfoBody(0, rows)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := s.sendGameUpperRawClass(session, currentEpicBookInfoWireOpcode, body, 0); err != nil {
|
||||
return err
|
||||
}
|
||||
session.selectedEpicBookBootstrapCharacterID = session.selectedCharacterID
|
||||
s.logGameEvent(session, "game-epic-book-snapshot-sent", "source", source, "account_id", accountID, "entries", len(rows), "wire_opcode", currentEpicBookInfoWireOpcode)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Service) handleCurrentEpicBookMakeItem(session *gameSession, body []byte) error {
|
||||
equipmentID, err := decodeCurrentEpicBookMakeItemRequest(body)
|
||||
if err != nil {
|
||||
s.logGameEvent(session, "game-epic-book-make-item-blocked", "body_len", len(body), "reason", "current_exe_op788_request_malformed", "error", err)
|
||||
return s.sendGameUpperRawClass(session, uint16(dnfenum.CmdPacketEpicBookMakeItem), buildCurrentEpicBookMakeItemResult(false, 0), 1)
|
||||
}
|
||||
result, err := s.commitCurrentEpicBookMakeItem(context.Background(), session, equipmentID, time.Now().UTC())
|
||||
if err != nil {
|
||||
errorCode := currentEpicBookErrorCondition
|
||||
if errors.Is(err, errDungeonPickupInventoryFull) || errors.Is(err, dnfdungeon.ErrPickupInventoryFull) {
|
||||
errorCode = currentEpicBookErrorInventory
|
||||
}
|
||||
s.logGameEvent(session, "game-epic-book-make-item-rejected", "equipment_id", equipmentID, "error_code", errorCode, "error", err)
|
||||
return s.sendGameUpperRawClass(session, uint16(dnfenum.CmdPacketEpicBookMakeItem), buildCurrentEpicBookMakeItemResult(false, errorCode), 1)
|
||||
}
|
||||
if err := s.sendGameUpperRawClass(session, uint16(dnfenum.CmdPacketEpicBookMakeItem), buildCurrentEpicBookMakeItemResult(true, 0), 1); err != nil {
|
||||
return err
|
||||
}
|
||||
if len(result.ItemUpdates) > 0 {
|
||||
if err := s.sendGameUpperRawClass(session, uint16(dnfenum.CmdPacketWalkoutPartyMember), buildCurrentItemUpdateBody(dnfrepo.MainInventoryListType, result.ItemUpdates), 0); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
syncBody, err := buildCurrentEpicBookInfoBody(1, []currentEpicBookBalanceRow{{FragmentID: result.FragmentID, Balance: result.FragmentBalance}})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return s.sendGameUpperRawClass(session, currentEpicBookInfoWireOpcode, syncBody, 0)
|
||||
}
|
||||
|
||||
func (s *Service) commitCurrentEpicBookMakeItem(ctx context.Context, session *gameSession, equipmentID uint32, now time.Time) (currentEpicBookCraftResult, error) {
|
||||
if s == nil || session == nil || session.selectedCharacterID == 0 {
|
||||
return currentEpicBookCraftResult{}, errCurrentEpicBookUnavailable
|
||||
}
|
||||
catalog, err := s.currentEpicBookCatalog()
|
||||
if err != nil {
|
||||
return currentEpicBookCraftResult{}, err
|
||||
}
|
||||
entry, ok := catalog.EntryByEquipment(equipmentID)
|
||||
if !ok {
|
||||
return currentEpicBookCraftResult{}, fmt.Errorf("%w: equipment=%d recipe missing", errCurrentEpicBookCondition, equipmentID)
|
||||
}
|
||||
items, err := s.currentPVFItemCatalog()
|
||||
if err != nil {
|
||||
return currentEpicBookCraftResult{}, err
|
||||
}
|
||||
outputDefinition, err := items.ResolveItem(equipmentID)
|
||||
if err != nil || outputDefinition.Kind != dungeonDropItemEquipment || outputDefinition.Rarity != 4 {
|
||||
return currentEpicBookCraftResult{}, fmt.Errorf("%w: equipment=%d is not PVF epic: %v", errCurrentEpicBookCondition, equipmentID, err)
|
||||
}
|
||||
for _, material := range entry.Recipe.Materials {
|
||||
definition, resolveErr := items.ResolveItem(material.ItemID)
|
||||
if resolveErr != nil || definition.Kind != dungeonDropItemStackable {
|
||||
return currentEpicBookCraftResult{}, fmt.Errorf("%w: material=%d unresolved: %v", errCurrentEpicBookCondition, material.ItemID, resolveErr)
|
||||
}
|
||||
}
|
||||
repositories, ok := s.repositoryGroup()
|
||||
if !ok || repositories.Character == nil || repositories.EpicBookCraft == nil {
|
||||
return currentEpicBookCraftResult{}, errCurrentEpicBookUnavailable
|
||||
}
|
||||
accountID := strings.TrimSpace(s.accountIDForSession(session))
|
||||
characterID := strconv.Itoa(int(session.selectedCharacterID))
|
||||
character, found, err := repositories.Character.Load(ctx, characterID)
|
||||
if err != nil || !found || strings.TrimSpace(character.AccountID) != accountID {
|
||||
return currentEpicBookCraftResult{}, fmt.Errorf("%w: character ownership", errCurrentEpicBookCondition)
|
||||
}
|
||||
if now.IsZero() {
|
||||
now = time.Now().UTC()
|
||||
}
|
||||
result := currentEpicBookCraftResult{FragmentID: entry.FragmentID}
|
||||
err = repositories.EpicBookCraft.WithinEpicBookCraft(ctx, accountID, characterID, func(epicBooks dnfrepo.EpicBookRepository, accountInventories dnfrepo.AccountInventoryRepository, inventories dnfrepo.InventoryRepository, _ dnfrepo.EquipmentRepository) error {
|
||||
book, bookFound, loadErr := epicBooks.Load(ctx, accountID)
|
||||
if loadErr != nil {
|
||||
return loadErr
|
||||
}
|
||||
if !bookFound {
|
||||
book = dnfrepo.EpicBookRecord{AccountID: accountID}
|
||||
}
|
||||
if book.Balances[equipmentID] < entry.Recipe.FragmentCount {
|
||||
return fmt.Errorf("%w: fragment equipment=%d have=%d need=%d", errCurrentEpicBookCondition, equipmentID, book.Balances[equipmentID], entry.Recipe.FragmentCount)
|
||||
}
|
||||
accountInventory, accountInventoryFound, loadErr := accountInventories.Load(ctx, accountID)
|
||||
if loadErr != nil {
|
||||
return loadErr
|
||||
}
|
||||
if !accountInventoryFound {
|
||||
return errCurrentEpicBookInventoryUnavailable
|
||||
}
|
||||
accountInventory = dnfrepo.CloneAccountInventory(accountInventory)
|
||||
inventory, inventoryFound, loadErr := inventories.Load(ctx, characterID)
|
||||
if loadErr != nil {
|
||||
return loadErr
|
||||
}
|
||||
if !inventoryFound {
|
||||
return errCurrentEpicBookInventoryUnavailable
|
||||
}
|
||||
inventory = dnfrepo.CloneInventory(inventory)
|
||||
updates, consumeErr := consumeCurrentEpicBookMaterials(&accountInventory, entry.Recipe.Materials)
|
||||
if consumeErr != nil {
|
||||
return consumeErr
|
||||
}
|
||||
// 史诗图鉴合成的产物同样不能落进未解锁的背包扩展行。
|
||||
outputDefinition = limitCurrentMainInventoryDefinitionSlots(
|
||||
outputDefinition,
|
||||
s.currentInventoryPlacementMainSlotCount(ctx, &inventory, characterID),
|
||||
)
|
||||
slot, stack, placeErr := dnfdungeon.PlacePickupItem(&inventory, currentDungeonPickupPlacement(outputDefinition, 1))
|
||||
if placeErr != nil {
|
||||
return mapCurrentDungeonPickupOwnerError(placeErr)
|
||||
}
|
||||
outputUpdate := currentItemListEntryFromStack(dnfrepo.MainInventoryListType, int16(slot), stack)
|
||||
stack.RawEntry = append([]byte(nil), outputUpdate.data[:]...)
|
||||
inventory.Slots[currentDungeonPickupMainSlotKey(int16(slot))] = stack
|
||||
updates = append(updates, outputUpdate)
|
||||
|
||||
book = dnfrepo.CloneEpicBook(book)
|
||||
book.Balances[equipmentID] -= entry.Recipe.FragmentCount
|
||||
result.FragmentBalance = book.Balances[equipmentID]
|
||||
book.UpdatedAt = now
|
||||
accountInventory.UpdatedAt = now
|
||||
inventory.UpdatedAt = now
|
||||
if err := epicBooks.Save(ctx, book); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := accountInventories.Save(ctx, accountInventory); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := dnfrepo.SaveInventoryFields(ctx, inventories, inventory, dnfrepo.InventoryFieldSlots); err != nil {
|
||||
return err
|
||||
}
|
||||
result.ItemUpdates = append([]currentItemListEntry(nil), updates...)
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
return currentEpicBookCraftResult{}, err
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func consumeCurrentEpicBookMaterials(inventory *dnfrepo.AccountInventoryRecord, materials []dnfepicbook.Material) ([]currentItemListEntry, error) {
|
||||
if inventory == nil {
|
||||
return nil, errCurrentEpicBookInventoryUnavailable
|
||||
}
|
||||
required := make(map[uint32]uint64, len(materials))
|
||||
for _, material := range materials {
|
||||
if material.ItemID == 0 || material.Count == 0 || required[material.ItemID] > math.MaxUint64-uint64(material.Count) {
|
||||
return nil, errCurrentEpicBookCondition
|
||||
}
|
||||
required[material.ItemID] += uint64(material.Count)
|
||||
}
|
||||
type candidate struct {
|
||||
key string
|
||||
slot int16
|
||||
stack dnfrepo.ItemStack
|
||||
}
|
||||
candidates := make(map[uint32][]candidate, len(required))
|
||||
available := make(map[uint32]uint64, len(required))
|
||||
for key, stack := range inventory.Slots {
|
||||
listType, slot, ok := parseSceneInventorySlotKey(key)
|
||||
if !ok || !dnfrepo.IsAccountSharedInventorySlot(listType, slot) || stack.Count <= 0 || currentNPCShopItemLocked(stack) || stack.ItemID <= 0 || stack.ItemID > math.MaxUint32 {
|
||||
continue
|
||||
}
|
||||
itemID := uint32(stack.ItemID)
|
||||
if _, needed := required[itemID]; !needed {
|
||||
continue
|
||||
}
|
||||
available[itemID] += uint64(stack.Count)
|
||||
candidates[itemID] = append(candidates[itemID], candidate{key: key, slot: slot, stack: stack})
|
||||
}
|
||||
for itemID, count := range required {
|
||||
if available[itemID] < count {
|
||||
return nil, fmt.Errorf("%w: material=%d have=%d need=%d", errCurrentEpicBookCondition, itemID, available[itemID], count)
|
||||
}
|
||||
}
|
||||
itemIDs := make([]uint32, 0, len(required))
|
||||
for itemID := range required {
|
||||
itemIDs = append(itemIDs, itemID)
|
||||
}
|
||||
sort.Slice(itemIDs, func(i, j int) bool { return itemIDs[i] < itemIDs[j] })
|
||||
updates := make([]currentItemListEntry, 0)
|
||||
for _, itemID := range itemIDs {
|
||||
sort.Slice(candidates[itemID], func(i, j int) bool { return candidates[itemID][i].slot < candidates[itemID][j].slot })
|
||||
remaining := required[itemID]
|
||||
for _, candidate := range candidates[itemID] {
|
||||
stack := inventory.Slots[candidate.key]
|
||||
consumed := min(remaining, uint64(stack.Count))
|
||||
stack.Count -= int64(consumed)
|
||||
remaining -= consumed
|
||||
if stack.Count == 0 {
|
||||
delete(inventory.Slots, candidate.key)
|
||||
var empty currentItemListEntry
|
||||
empty.patchCore(candidate.slot, 0, 0)
|
||||
updates = append(updates, empty)
|
||||
} else {
|
||||
update := currentItemListEntryFromStack(dnfrepo.MainInventoryListType, candidate.slot, stack)
|
||||
stack.RawEntry = append([]byte(nil), update.data[:]...)
|
||||
inventory.Slots[candidate.key] = stack
|
||||
updates = append(updates, update)
|
||||
}
|
||||
if remaining == 0 {
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
return updates, nil
|
||||
}
|
||||
Reference in new issue
Block a user