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,508 @@
|
||||
// Package guardianshield owns the Guardian's current-client five-slot shield
|
||||
// deck and its main-shield actor projection. The catalog itself remains PVF
|
||||
// owned and is supplied through a typed resolver by dnfbridge.
|
||||
package guardianshield
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"longheng.io/server/internal/modules/dnf/alignedcmd"
|
||||
"longheng.io/server/internal/modules/dnf/itemquality"
|
||||
dnfquest "longheng.io/server/internal/modules/dnf/quest"
|
||||
dnfrepo "longheng.io/server/internal/modules/dnf/repository"
|
||||
)
|
||||
|
||||
const (
|
||||
DeckSlotCount = 5
|
||||
MainDeckSlot = 0
|
||||
ActorSlot = int16(24)
|
||||
|
||||
WireListEquipped byte = 33
|
||||
WireListCatalog byte = 34
|
||||
|
||||
guardianJob = 12
|
||||
currentRawItemEntrySize = 0x77
|
||||
)
|
||||
|
||||
const projectionMarker = "guardian_shield_deck_projection"
|
||||
|
||||
var (
|
||||
ErrOwnerUnavailable = errors.New("guardian shield owner unavailable")
|
||||
ErrCharacterRequired = errors.New("guardian shield selected character is required")
|
||||
ErrCharacterNotFound = errors.New("guardian shield character not found")
|
||||
ErrOwnerMismatch = errors.New("guardian shield character owner mismatch")
|
||||
ErrCharacterIneligible = errors.New("guardian shield character job or grow type is ineligible")
|
||||
ErrResolverRequired = errors.New("guardian shield PVF resolver is required")
|
||||
ErrQuestRepositoryRequired = errors.New("guardian shield quest repository is required")
|
||||
ErrClearQuestRequired = errors.New("guardian shield catalog clear quest is required")
|
||||
ErrClearQuestIncomplete = errors.New("guardian shield catalog clear quest is not completed")
|
||||
ErrUnlockKindInvalid = errors.New("guardian shield catalog unlock kind is invalid")
|
||||
ErrMinimumLevelRequired = errors.New("guardian shield catalog minimum level is required")
|
||||
ErrLevelInsufficient = errors.New("guardian shield character level is below the catalog minimum")
|
||||
ErrMoveUnsupported = errors.New("guardian shield move endpoints are unsupported")
|
||||
ErrDeckSlotInvalid = errors.New("guardian shield deck slot is outside the current client range")
|
||||
ErrDeckSlotEmpty = errors.New("guardian shield deck source slot is empty")
|
||||
ErrDeckDuplicate = errors.New("guardian shield deck contains a duplicate item")
|
||||
ErrMainDeckMutationRequiresMove = errors.New("guardian shield main slot can change only through move-itemspace")
|
||||
ErrProjectionConflict = errors.New("guardian shield main projection conflicts with an existing slot-24 item")
|
||||
)
|
||||
|
||||
var deckStatKeys = [DeckSlotCount]string{
|
||||
"guardian_shield_deck_0",
|
||||
"guardian_shield_deck_1",
|
||||
"guardian_shield_deck_2",
|
||||
"guardian_shield_deck_3",
|
||||
"guardian_shield_deck_4",
|
||||
}
|
||||
|
||||
type Deck [DeckSlotCount]uint32
|
||||
|
||||
type MoveCommand struct {
|
||||
CharacterID uint16
|
||||
AccountID string
|
||||
SourceListType byte
|
||||
SourceSlotIndex int16
|
||||
SourceShieldItemID uint32
|
||||
DestinationListType byte
|
||||
DestinationSlotIndex int16
|
||||
}
|
||||
|
||||
type Result struct {
|
||||
Deck Deck
|
||||
Changed bool
|
||||
MainChanged bool
|
||||
}
|
||||
|
||||
type Owner struct {
|
||||
assets dnfrepo.CharacterAssetUnitOfWork
|
||||
quests dnfrepo.QuestRepository
|
||||
resolver alignedcmd.GuardianShieldResolver
|
||||
}
|
||||
|
||||
func NewOwner(repositories dnfrepo.Group, resolver alignedcmd.GuardianShieldResolver) (*Owner, error) {
|
||||
if repositories.CharacterAssets == nil {
|
||||
return nil, ErrOwnerUnavailable
|
||||
}
|
||||
if resolver == nil {
|
||||
return nil, ErrResolverRequired
|
||||
}
|
||||
return &Owner{assets: repositories.CharacterAssets, quests: repositories.Quest, resolver: resolver}, nil
|
||||
}
|
||||
|
||||
func IsWireList(listType byte) bool {
|
||||
return listType == WireListEquipped || listType == WireListCatalog
|
||||
}
|
||||
|
||||
func DeckFromCharacter(character dnfrepo.CharacterRecord) Deck {
|
||||
var deck Deck
|
||||
for index, key := range deckStatKeys {
|
||||
if value := character.Stats[key]; value > 0 && value <= int64(^uint32(0)) {
|
||||
deck[index] = uint32(value)
|
||||
}
|
||||
}
|
||||
return deck
|
||||
}
|
||||
|
||||
func LoadDeck(character dnfrepo.CharacterRecord) (Deck, error) {
|
||||
var deck Deck
|
||||
for index, key := range deckStatKeys {
|
||||
value := character.Stats[key]
|
||||
if value < 0 || value > int64(^uint32(0)) {
|
||||
return Deck{}, fmt.Errorf("guardian shield persisted slot=%d value=%d is outside u32", index, value)
|
||||
}
|
||||
deck[index] = uint32(value)
|
||||
}
|
||||
return deck, nil
|
||||
}
|
||||
|
||||
func EligibleGrowType(character dnfrepo.CharacterRecord) (byte, error) {
|
||||
return eligibleGrowType(character)
|
||||
}
|
||||
|
||||
func (o *Owner) Move(ctx context.Context, command MoveCommand) (Result, error) {
|
||||
if command.CharacterID == 0 {
|
||||
return Result{}, ErrCharacterRequired
|
||||
}
|
||||
if !IsWireList(command.SourceListType) || !IsWireList(command.DestinationListType) {
|
||||
return Result{}, fmt.Errorf("%w: source=%d destination=%d", ErrMoveUnsupported, command.SourceListType, command.DestinationListType)
|
||||
}
|
||||
return o.mutate(ctx, command.CharacterID, command.AccountID, func(deck Deck) (Deck, error) {
|
||||
switch {
|
||||
case command.SourceListType == WireListCatalog && command.DestinationListType == WireListEquipped:
|
||||
if command.SourceSlotIndex != 0 || command.DestinationSlotIndex != MainDeckSlot || command.SourceShieldItemID == 0 {
|
||||
return Deck{}, fmt.Errorf("%w: catalog source=(%d,item=%d) destination=%d", ErrMoveUnsupported, command.SourceSlotIndex, command.SourceShieldItemID, command.DestinationSlotIndex)
|
||||
}
|
||||
deck[MainDeckSlot] = command.SourceShieldItemID
|
||||
for index := 1; index < DeckSlotCount; index++ {
|
||||
if deck[index] == command.SourceShieldItemID {
|
||||
deck[index] = 0
|
||||
}
|
||||
}
|
||||
return deck, nil
|
||||
case command.SourceListType == WireListEquipped && command.DestinationListType == WireListCatalog:
|
||||
if command.SourceSlotIndex != MainDeckSlot || command.DestinationSlotIndex != DeckSlotCount {
|
||||
return Deck{}, fmt.Errorf("%w: deck source=%d catalog destination=%d", ErrMoveUnsupported, command.SourceSlotIndex, command.DestinationSlotIndex)
|
||||
}
|
||||
if deck[command.SourceSlotIndex] == 0 {
|
||||
return Deck{}, fmt.Errorf("%w: source=%d", ErrDeckSlotEmpty, command.SourceSlotIndex)
|
||||
}
|
||||
deck[command.SourceSlotIndex] = 0
|
||||
return deck, nil
|
||||
case command.SourceListType == WireListEquipped && command.DestinationListType == WireListEquipped:
|
||||
if !validDeckSlot(command.SourceSlotIndex) || !validDeckSlot(command.DestinationSlotIndex) {
|
||||
return Deck{}, fmt.Errorf("%w: source=%d destination=%d", ErrDeckSlotInvalid, command.SourceSlotIndex, command.DestinationSlotIndex)
|
||||
}
|
||||
if command.SourceSlotIndex != MainDeckSlot && command.DestinationSlotIndex != MainDeckSlot {
|
||||
return Deck{}, fmt.Errorf("%w: backup-only source=%d destination=%d must use op657", ErrMoveUnsupported, command.SourceSlotIndex, command.DestinationSlotIndex)
|
||||
}
|
||||
if deck[command.SourceSlotIndex] == 0 {
|
||||
return Deck{}, fmt.Errorf("%w: source=%d", ErrDeckSlotEmpty, command.SourceSlotIndex)
|
||||
}
|
||||
deck[command.SourceSlotIndex], deck[command.DestinationSlotIndex] = deck[command.DestinationSlotIndex], deck[command.SourceSlotIndex]
|
||||
return deck, nil
|
||||
default:
|
||||
return Deck{}, fmt.Errorf("%w: source=%d destination=%d", ErrMoveUnsupported, command.SourceListType, command.DestinationListType)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func (o *Owner) SaveDeck(ctx context.Context, characterID uint16, accountID string, requested Deck) (Result, error) {
|
||||
if characterID == 0 {
|
||||
return Result{}, ErrCharacterRequired
|
||||
}
|
||||
return o.mutate(ctx, characterID, accountID, func(before Deck) (Deck, error) {
|
||||
if requested[MainDeckSlot] != before[MainDeckSlot] {
|
||||
return Deck{}, fmt.Errorf(
|
||||
"%w: persisted=%d requested=%d",
|
||||
ErrMainDeckMutationRequiresMove,
|
||||
before[MainDeckSlot],
|
||||
requested[MainDeckSlot],
|
||||
)
|
||||
}
|
||||
return requested, nil
|
||||
})
|
||||
}
|
||||
|
||||
func (o *Owner) mutate(
|
||||
ctx context.Context,
|
||||
selectedCharacterID uint16,
|
||||
accountID string,
|
||||
change func(Deck) (Deck, error),
|
||||
) (Result, error) {
|
||||
if o == nil || o.assets == nil {
|
||||
return Result{}, ErrOwnerUnavailable
|
||||
}
|
||||
if o.resolver == nil {
|
||||
return Result{}, ErrResolverRequired
|
||||
}
|
||||
if ctx == nil {
|
||||
ctx = context.Background()
|
||||
}
|
||||
characterID := strconv.FormatUint(uint64(selectedCharacterID), 10)
|
||||
accountID = strings.TrimSpace(accountID)
|
||||
var result Result
|
||||
err := o.assets.WithinCharacterAssets(ctx, characterID, func(
|
||||
characters dnfrepo.CharacterRepository,
|
||||
_ dnfrepo.InventoryRepository,
|
||||
equipment dnfrepo.EquipmentRepository,
|
||||
) error {
|
||||
character, found, err := characters.Load(ctx, characterID)
|
||||
if err != nil {
|
||||
return fmt.Errorf("load guardian shield character: %w", err)
|
||||
}
|
||||
if !found {
|
||||
return fmt.Errorf("%w: character=%s", ErrCharacterNotFound, characterID)
|
||||
}
|
||||
if strings.TrimSpace(character.CharacterID) != characterID ||
|
||||
(accountID != "" && strings.TrimSpace(character.AccountID) != accountID) {
|
||||
return fmt.Errorf("%w: account=%q character=%s", ErrOwnerMismatch, accountID, characterID)
|
||||
}
|
||||
growType, err := eligibleGrowType(character)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
before, err := LoadDeck(character)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
after, err := change(before)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
resolutions, err := o.validateDeck(ctx, after, growType)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// Quest completion is monotonic. When any catalog row is quest-gated,
|
||||
// read its authorization snapshot while the character-asset UOW is open,
|
||||
// before either deck Stats or slot24 is saved. Level-only rows do not
|
||||
// require a quest repository or record.
|
||||
if err := o.validateUnlocks(ctx, character, resolutions); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
worn, found, err := equipment.Load(ctx, characterID)
|
||||
if err != nil {
|
||||
return fmt.Errorf("load guardian shield equipment: %w", err)
|
||||
}
|
||||
if !found {
|
||||
worn = dnfrepo.EquipmentRecord{CharacterID: characterID}
|
||||
}
|
||||
worn = dnfrepo.CloneEquipment(worn)
|
||||
worn.CharacterID = characterID
|
||||
if worn.Entries == nil {
|
||||
worn.Entries = make(map[string]dnfrepo.EquipmentEntry)
|
||||
}
|
||||
projectionChanged, err := applyMainProjection(&worn, after[MainDeckSlot], resolutions[MainDeckSlot])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
changed := before != after
|
||||
mainChanged := before[MainDeckSlot] != after[MainDeckSlot]
|
||||
if changed {
|
||||
character = dnfrepo.CloneCharacter(character)
|
||||
if character.Stats == nil {
|
||||
character.Stats = make(map[string]int64, DeckSlotCount)
|
||||
}
|
||||
for index, key := range deckStatKeys {
|
||||
character.Stats[key] = int64(after[index])
|
||||
}
|
||||
character.UpdatedAt = time.Now()
|
||||
if err := dnfrepo.SaveCharacterFields(ctx, characters, character, dnfrepo.CharacterFieldStats); err != nil {
|
||||
return fmt.Errorf("save guardian shield deck: %w", err)
|
||||
}
|
||||
}
|
||||
if projectionChanged {
|
||||
worn.UpdatedAt = time.Now()
|
||||
if err := dnfrepo.SaveEquipmentFields(ctx, equipment, worn, dnfrepo.EquipmentFieldEntries); err != nil {
|
||||
return fmt.Errorf("save guardian shield main projection: %w", err)
|
||||
}
|
||||
}
|
||||
result = Result{Deck: after, Changed: changed, MainChanged: mainChanged || projectionChanged}
|
||||
return nil
|
||||
})
|
||||
return result, err
|
||||
}
|
||||
|
||||
func (o *Owner) validateUnlocks(
|
||||
ctx context.Context,
|
||||
character dnfrepo.CharacterRecord,
|
||||
resolutions [DeckSlotCount]alignedcmd.GuardianShieldResolution,
|
||||
) error {
|
||||
needsQuest := false
|
||||
for _, resolution := range resolutions {
|
||||
if resolution.ItemID != 0 && resolution.UnlockKind == alignedcmd.GuardianShieldUnlockQuest {
|
||||
needsQuest = true
|
||||
break
|
||||
}
|
||||
}
|
||||
var record dnfrepo.QuestRecord
|
||||
if needsQuest {
|
||||
if o == nil || o.quests == nil {
|
||||
return ErrQuestRepositoryRequired
|
||||
}
|
||||
characterID := strings.TrimSpace(character.CharacterID)
|
||||
var found bool
|
||||
var err error
|
||||
record, found, err = o.quests.Load(ctx, characterID)
|
||||
if err != nil {
|
||||
return fmt.Errorf("load guardian shield clear quests: %w", err)
|
||||
}
|
||||
if !found {
|
||||
record = dnfrepo.QuestRecord{CharacterID: characterID}
|
||||
}
|
||||
if strings.TrimSpace(record.CharacterID) != characterID {
|
||||
return fmt.Errorf("%w: quest character=%q selected=%q", ErrOwnerMismatch, record.CharacterID, characterID)
|
||||
}
|
||||
}
|
||||
for slot, resolution := range resolutions {
|
||||
if resolution.ItemID == 0 {
|
||||
continue
|
||||
}
|
||||
if err := ValidateUnlock(character, record, resolution); err != nil {
|
||||
return fmt.Errorf("validate guardian shield slot=%d item=%d unlock: %w", slot, resolution.ItemID, err)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ValidateUnlock applies one shieldwindownewdata authorization to the selected
|
||||
// character. The UI catalog is not an authorization boundary: forged list34,
|
||||
// op19 and op657 packets must still satisfy either the PVF quest or level gate.
|
||||
func ValidateUnlock(
|
||||
character dnfrepo.CharacterRecord,
|
||||
record dnfrepo.QuestRecord,
|
||||
resolution alignedcmd.GuardianShieldResolution,
|
||||
) error {
|
||||
switch resolution.UnlockKind {
|
||||
case alignedcmd.GuardianShieldUnlockQuest:
|
||||
if resolution.ClearQuestID <= 0 {
|
||||
return fmt.Errorf("%w: item=%d clear_quest=%d", ErrClearQuestRequired, resolution.ItemID, resolution.ClearQuestID)
|
||||
}
|
||||
if !dnfquest.IsCompleted(record, resolution.ClearQuestID) {
|
||||
state, statesFound := record.States[resolution.ClearQuestID]
|
||||
progress, progressFound := record.Progress[resolution.ClearQuestID]
|
||||
return fmt.Errorf(
|
||||
"%w: item=%d clear_quest=%d states_status=%q states_present=%t progress_status=%q progress_present=%t",
|
||||
ErrClearQuestIncomplete,
|
||||
resolution.ItemID,
|
||||
resolution.ClearQuestID,
|
||||
state.Status,
|
||||
statesFound,
|
||||
progress.Status,
|
||||
progressFound,
|
||||
)
|
||||
}
|
||||
return nil
|
||||
case alignedcmd.GuardianShieldUnlockLevel:
|
||||
if resolution.MinimumLevel <= 0 {
|
||||
return fmt.Errorf("%w: item=%d minimum_level=%d", ErrMinimumLevelRequired, resolution.ItemID, resolution.MinimumLevel)
|
||||
}
|
||||
if int64(character.Level) < resolution.MinimumLevel {
|
||||
return fmt.Errorf(
|
||||
"%w: item=%d character_level=%d minimum_level=%d",
|
||||
ErrLevelInsufficient,
|
||||
resolution.ItemID,
|
||||
character.Level,
|
||||
resolution.MinimumLevel,
|
||||
)
|
||||
}
|
||||
return nil
|
||||
default:
|
||||
return fmt.Errorf("%w: item=%d kind=%d", ErrUnlockKindInvalid, resolution.ItemID, resolution.UnlockKind)
|
||||
}
|
||||
}
|
||||
|
||||
func (o *Owner) validateDeck(ctx context.Context, deck Deck, growType byte) ([DeckSlotCount]alignedcmd.GuardianShieldResolution, error) {
|
||||
var resolutions [DeckSlotCount]alignedcmd.GuardianShieldResolution
|
||||
seen := make(map[uint32]int, DeckSlotCount)
|
||||
for index, itemID := range deck {
|
||||
if itemID == 0 {
|
||||
continue
|
||||
}
|
||||
if previous, exists := seen[itemID]; exists {
|
||||
return resolutions, fmt.Errorf("%w: item=%d slots=%d,%d", ErrDeckDuplicate, itemID, previous, index)
|
||||
}
|
||||
seen[itemID] = index
|
||||
resolution, err := o.resolver(ctx, itemID, growType)
|
||||
if err != nil {
|
||||
return resolutions, fmt.Errorf("validate guardian shield slot=%d item=%d: %w", index, itemID, err)
|
||||
}
|
||||
if resolution.ItemID != itemID {
|
||||
return resolutions, fmt.Errorf("validate guardian shield slot=%d item=%d resolved=%d", index, itemID, resolution.ItemID)
|
||||
}
|
||||
resolutions[index] = resolution
|
||||
}
|
||||
return resolutions, nil
|
||||
}
|
||||
|
||||
func eligibleGrowType(character dnfrepo.CharacterRecord) (byte, error) {
|
||||
job, err := strconv.ParseInt(strings.TrimSpace(character.Job), 10, 16)
|
||||
if err != nil || job != guardianJob {
|
||||
return 0, fmt.Errorf("%w: job=%q", ErrCharacterIneligible, character.Job)
|
||||
}
|
||||
growValue, found := character.Stats["grow_type"]
|
||||
if !found || growValue < 0 || growValue > 0xff {
|
||||
return 0, fmt.Errorf("%w: grow_type=%d present=%t", ErrCharacterIneligible, growValue, found)
|
||||
}
|
||||
growType := byte(growValue) & 0x0f
|
||||
if growType != 1 && growType != 2 {
|
||||
return 0, fmt.Errorf("%w: grow_type=%d normalized=%d", ErrCharacterIneligible, growValue, growType)
|
||||
}
|
||||
return growType, nil
|
||||
}
|
||||
|
||||
func validDeckSlot(slot int16) bool {
|
||||
return slot >= 0 && slot < DeckSlotCount
|
||||
}
|
||||
|
||||
// MainProjectionItemID returns the Guardian-owned visible shield in actor slot
|
||||
// 24. A generic support-weapon or another profession's offhand must not be
|
||||
// mistaken for this projection: only the row written by this owner's atomic
|
||||
// deck transaction carries projectionMarker.
|
||||
func MainProjectionItemID(record dnfrepo.EquipmentRecord) (uint32, bool) {
|
||||
entry, found := record.Entries[strconv.Itoa(int(ActorSlot))]
|
||||
if !found || entry.SlotIndex != ActorSlot || entry.ItemID <= 0 ||
|
||||
entry.ItemID > int64(^uint32(0)) || entry.Extra[projectionMarker] != "1" {
|
||||
return 0, false
|
||||
}
|
||||
return uint32(entry.ItemID), true
|
||||
}
|
||||
|
||||
func applyMainProjection(record *dnfrepo.EquipmentRecord, itemID uint32, resolution alignedcmd.GuardianShieldResolution) (bool, error) {
|
||||
key := strconv.Itoa(int(ActorSlot))
|
||||
current, occupied := record.Entries[key]
|
||||
if itemID == 0 {
|
||||
if occupied && current.Extra[projectionMarker] == "1" {
|
||||
delete(record.Entries, key)
|
||||
return true, nil
|
||||
}
|
||||
return false, nil
|
||||
}
|
||||
if occupied && current.ItemID != int64(itemID) && current.Extra[projectionMarker] != "1" {
|
||||
return false, fmt.Errorf("%w: existing=%d requested=%d", ErrProjectionConflict, current.ItemID, itemID)
|
||||
}
|
||||
if occupied && current.ItemID == int64(itemID) && current.Extra[projectionMarker] == "1" {
|
||||
return false, nil
|
||||
}
|
||||
record.Entries[key] = BuildMainProjectionEntry(itemID, resolution)
|
||||
return true, nil
|
||||
}
|
||||
|
||||
// DeckStatKey returns the character Stats key that persists deck slot's item.
|
||||
func DeckStatKey(slot int) string {
|
||||
if slot < 0 || slot >= DeckSlotCount {
|
||||
slot = 0
|
||||
}
|
||||
return deckStatKeys[slot]
|
||||
}
|
||||
|
||||
// IsMainProjectionEntry reports whether the equipment row is the Guardian
|
||||
// deck's actor-slot-24 projection. The worn slot is also used by the Blade
|
||||
// Dancer off-hand weapon, so callers that render a projection-specific visual
|
||||
// (for example the mode0 scene-object appearance table) must gate on this
|
||||
// marker instead of the bare slot number.
|
||||
func IsMainProjectionEntry(entry dnfrepo.EquipmentEntry) bool {
|
||||
if entry.SlotIndex != ActorSlot {
|
||||
return false
|
||||
}
|
||||
return strings.TrimSpace(entry.Extra[projectionMarker]) == "1"
|
||||
}
|
||||
|
||||
// BuildMainProjectionEntry constructs the durable actor-slot-24 projection
|
||||
// record for the deck's visible main shield. It is the same record the atomic
|
||||
// deck transaction persists, exported so the bridge login pre-sync can repair
|
||||
// legacy guardians whose deck[0] never reached the equipment table (or whose
|
||||
// equipment row was left behind after a deck reset) without an active command
|
||||
// owner. SlotIndex, the minimal raw entry and current_exe_equipment_type=24
|
||||
// keep the row visible in the list3 body wire and the mode0 scene-object
|
||||
// appearance table; projectionMarker distinguishes it from a generic
|
||||
// support-weapon or another profession's slot-24 offhand.
|
||||
func BuildMainProjectionEntry(itemID uint32, resolution alignedcmd.GuardianShieldResolution) dnfrepo.EquipmentEntry {
|
||||
raw := make([]byte, currentRawItemEntrySize)
|
||||
binary.LittleEndian.PutUint16(raw[0:2], uint16(ActorSlot))
|
||||
binary.LittleEndian.PutUint32(raw[2:6], itemID)
|
||||
binary.LittleEndian.PutUint32(raw[6:10], itemquality.TopSeed)
|
||||
return dnfrepo.EquipmentEntry{
|
||||
SlotIndex: ActorSlot,
|
||||
ItemID: int64(itemID),
|
||||
RawEntry: raw,
|
||||
Extra: map[string]string{
|
||||
projectionMarker: "1",
|
||||
"source": "guardian_shield_deck",
|
||||
"item_kind": "equipment",
|
||||
"pvf_path": strings.TrimSpace(resolution.PVFPath),
|
||||
"equipment_type": strings.TrimSpace(resolution.EquipmentType),
|
||||
"current_exe_equipment_type": strconv.Itoa(int(ActorSlot)),
|
||||
"current_exe_runtime_move": "1",
|
||||
"quality_seed": strconv.FormatUint(uint64(itemquality.TopSeed), 10),
|
||||
},
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user