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,535 @@
|
||||
package dnfbridge
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"math"
|
||||
"path"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"longheng.io/server/internal/modules/dnf/dnfenum"
|
||||
dnfdungeon "longheng.io/server/internal/modules/dnf/dungeon"
|
||||
dnfpvf "longheng.io/server/internal/modules/dnf/pvf"
|
||||
dnfrepo "longheng.io/server/internal/modules/dnf/repository"
|
||||
"longheng.io/server/internal/modules/dnf/worldmap"
|
||||
)
|
||||
|
||||
const (
|
||||
currentDungeonTutorialRewardProgress = uint32(38)
|
||||
|
||||
currentDungeonTutorialRewardPVFPath = "etc/serverparameter.etc"
|
||||
currentDungeonTutorialRewardSection = "escalade tutorial reward"
|
||||
currentDungeonTutorialStackableList = "stackable/stackable.lst"
|
||||
|
||||
// Current main-list slots 3..8 are the six item quick slots. Slot 3 is
|
||||
// the first visible quick slot; ordinary consumables fall back to 65..120.
|
||||
currentDungeonTutorialQuickSlotStart = int16(3)
|
||||
currentDungeonTutorialQuickSlotEnd = int16(8)
|
||||
|
||||
currentDungeonTutorialRewardMarkerValue = int64(1)
|
||||
)
|
||||
|
||||
var (
|
||||
errDungeonTutorialRewardSourceRequired = errors.New("dnf tutorial reward PVF source is required")
|
||||
errDungeonTutorialRewardSectionMissing = errors.New("dnf tutorial reward PVF section is missing")
|
||||
errDungeonTutorialRewardRowInvalid = errors.New("dnf tutorial reward PVF row is invalid")
|
||||
errDungeonTutorialRewardMissing = errors.New("dnf tutorial reward progress has no PVF row")
|
||||
errDungeonTutorialRewardItemInvalid = errors.New("dnf tutorial reward item is not a supported consumable")
|
||||
errDungeonTutorialRewardAssetMissing = errors.New("dnf tutorial reward asset transaction is unavailable")
|
||||
errDungeonTutorialRewardInventoryFull = errors.New("dnf tutorial reward inventory is full")
|
||||
errDungeonTutorialRewardResponse = errors.New("dnf tutorial reward response is invalid")
|
||||
)
|
||||
|
||||
type pvfDungeonTutorialReward struct {
|
||||
Progress uint32
|
||||
ItemID uint32
|
||||
Count uint32
|
||||
}
|
||||
|
||||
type pvfDungeonTutorialRewardCatalog struct {
|
||||
byProgress map[uint32][]pvfDungeonTutorialReward
|
||||
}
|
||||
|
||||
type currentDungeonTutorialRewardItemDefinition struct {
|
||||
ItemID uint32
|
||||
PVFPath string
|
||||
StackableType string
|
||||
StackLimit int64
|
||||
SlotStart int16
|
||||
SlotEnd int16
|
||||
ExpirationDate time.Time
|
||||
}
|
||||
|
||||
func newPVFDungeonTutorialRewardCatalog(source dnfpvf.Source) (*pvfDungeonTutorialRewardCatalog, error) {
|
||||
if source == nil {
|
||||
return nil, errDungeonTutorialRewardSourceRequired
|
||||
}
|
||||
text, err := source.ReadText(currentDungeonTutorialRewardPVFPath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("read %s: %w", currentDungeonTutorialRewardPVFPath, err)
|
||||
}
|
||||
document, err := dnfpvf.Parse(currentDungeonTutorialRewardPVFPath, text)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("parse %s: %w", currentDungeonTutorialRewardPVFPath, err)
|
||||
}
|
||||
tokens, ok := document.Section(currentDungeonTutorialRewardSection)
|
||||
if !ok {
|
||||
return nil, errDungeonTutorialRewardSectionMissing
|
||||
}
|
||||
values := make([]int64, 0, len(tokens))
|
||||
for _, token := range tokens {
|
||||
if token.Kind != dnfpvf.TokenInt {
|
||||
return nil, fmt.Errorf(
|
||||
"%w: line=%d kind=%s raw=%q",
|
||||
errDungeonTutorialRewardRowInvalid,
|
||||
token.Line,
|
||||
token.Kind,
|
||||
token.Raw,
|
||||
)
|
||||
}
|
||||
values = append(values, token.Int)
|
||||
}
|
||||
if len(values) == 0 || len(values)%3 != 0 {
|
||||
return nil, fmt.Errorf("%w: value_count=%d want_positive_triples", errDungeonTutorialRewardRowInvalid, len(values))
|
||||
}
|
||||
|
||||
byProgress := make(map[uint32][]pvfDungeonTutorialReward)
|
||||
for index := 0; index < len(values); index += 3 {
|
||||
progress, itemID, count := values[index], values[index+1], values[index+2]
|
||||
if progress <= 0 || progress > math.MaxUint32 ||
|
||||
itemID <= 0 || itemID > math.MaxUint32 ||
|
||||
count <= 0 || count > math.MaxUint32 {
|
||||
return nil, fmt.Errorf(
|
||||
"%w: row=%d progress=%d item=%d count=%d",
|
||||
errDungeonTutorialRewardRowInvalid,
|
||||
index/3,
|
||||
progress,
|
||||
itemID,
|
||||
count,
|
||||
)
|
||||
}
|
||||
key := uint32(progress)
|
||||
if len(byProgress[key]) >= math.MaxUint8 {
|
||||
return nil, fmt.Errorf("%w: progress=%d reward_count_exceeds_u8", errDungeonTutorialRewardRowInvalid, key)
|
||||
}
|
||||
byProgress[key] = append(byProgress[key], pvfDungeonTutorialReward{
|
||||
Progress: key,
|
||||
ItemID: uint32(itemID),
|
||||
Count: uint32(count),
|
||||
})
|
||||
}
|
||||
return &pvfDungeonTutorialRewardCatalog{byProgress: byProgress}, nil
|
||||
}
|
||||
|
||||
func (c *pvfDungeonTutorialRewardCatalog) Rewards(progress uint32) []pvfDungeonTutorialReward {
|
||||
if c == nil {
|
||||
return nil
|
||||
}
|
||||
return append([]pvfDungeonTutorialReward(nil), c.byProgress[progress]...)
|
||||
}
|
||||
|
||||
type currentDungeonTutorialRewardDefinition struct {
|
||||
Reward pvfDungeonTutorialReward
|
||||
Item currentDungeonTutorialRewardItemDefinition
|
||||
}
|
||||
|
||||
type currentDungeonTutorialRewardRow struct {
|
||||
Slot uint16
|
||||
ItemID uint32
|
||||
Count uint32
|
||||
}
|
||||
|
||||
type currentDungeonTutorialRewardDelivery struct {
|
||||
Granted bool
|
||||
Rows []currentDungeonTutorialRewardRow
|
||||
}
|
||||
|
||||
func (s *Service) handleCurrentDungeonTutorialReward(session *gameSession, progress uint32) error {
|
||||
if session == nil || progress != currentDungeonTutorialRewardProgress {
|
||||
return nil
|
||||
}
|
||||
selectedCharacterID := session.selectedCharacterID
|
||||
if selectedCharacterID == 0 {
|
||||
s.logGameEvent(session, "game-dungeon-tutorial-reward-blocked",
|
||||
"progress", progress,
|
||||
"reason", "selected_character_missing")
|
||||
return nil
|
||||
}
|
||||
|
||||
session.dungeon.mu.Lock()
|
||||
defer session.dungeon.mu.Unlock()
|
||||
runtime := session.dungeon.runtime
|
||||
if runtime == nil || runtime.Session == nil || runtime.Room == nil {
|
||||
s.logGameEvent(session, "game-dungeon-tutorial-reward-blocked",
|
||||
"char_id", selectedCharacterID,
|
||||
"progress", progress,
|
||||
"reason", "active_dungeon_runtime_missing")
|
||||
return nil
|
||||
}
|
||||
if !dungeonRuntimeOwnsCharacter(runtime, selectedCharacterID) {
|
||||
s.logGameEvent(session, "game-dungeon-tutorial-reward-blocked",
|
||||
"char_id", selectedCharacterID,
|
||||
"runtime_char_id", runtime.Character.CharacterID,
|
||||
"progress", progress,
|
||||
"reason", "active_dungeon_runtime_character_owner_mismatch")
|
||||
return nil
|
||||
}
|
||||
snapshot := runtime.Session.Snapshot()
|
||||
if snapshot.Run.Status != worldmap.DungeonRunActive || !isPVFTutorialDungeonScene(runtime, snapshot.Scene) {
|
||||
s.logGameEvent(session, "game-dungeon-tutorial-reward-blocked",
|
||||
"char_id", selectedCharacterID,
|
||||
"dungeon_id", runtime.Dungeon.ID,
|
||||
"map_id", snapshot.Scene.Map.Map.ID,
|
||||
"run_status", snapshot.Run.Status,
|
||||
"progress", progress,
|
||||
"reason", "owned_active_pvf_tutorial_scene_missing")
|
||||
return nil
|
||||
}
|
||||
|
||||
definitions, err := s.resolveCurrentDungeonTutorialRewards(progress)
|
||||
if err != nil {
|
||||
s.logGameEvent(session, "game-dungeon-tutorial-reward-blocked",
|
||||
"char_id", selectedCharacterID,
|
||||
"dungeon_id", runtime.Dungeon.ID,
|
||||
"map_id", snapshot.Scene.Map.Map.ID,
|
||||
"progress", progress,
|
||||
"reason", "runtime_pvf_tutorial_reward_unavailable",
|
||||
"error", err)
|
||||
return nil
|
||||
}
|
||||
repositories, ok := s.repositoryGroup()
|
||||
if !ok || repositories.CharacterAssets == nil {
|
||||
s.logGameEvent(session, "game-dungeon-tutorial-reward-blocked",
|
||||
"char_id", selectedCharacterID,
|
||||
"progress", progress,
|
||||
"reason", "character_asset_transaction_missing",
|
||||
"error", errDungeonTutorialRewardAssetMissing)
|
||||
return nil
|
||||
}
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), createWriteTimeout)
|
||||
defer cancel()
|
||||
delivery, err := deliverCurrentDungeonTutorialReward(
|
||||
ctx,
|
||||
repositories.CharacterAssets,
|
||||
strconv.Itoa(int(selectedCharacterID)),
|
||||
progress,
|
||||
definitions,
|
||||
time.Now().UTC(),
|
||||
)
|
||||
if err != nil {
|
||||
s.logGameEvent(session, "game-dungeon-tutorial-reward-blocked",
|
||||
"char_id", selectedCharacterID,
|
||||
"dungeon_id", runtime.Dungeon.ID,
|
||||
"map_id", snapshot.Scene.Map.Map.ID,
|
||||
"progress", progress,
|
||||
"reason", "atomic_character_reward_transaction_failed",
|
||||
"error", err)
|
||||
return nil
|
||||
}
|
||||
payload, err := buildCurrentDungeonTutorialRewardSuccessPayload(delivery.Rows)
|
||||
if err != nil {
|
||||
s.logGameEvent(session, "game-dungeon-tutorial-reward-blocked-after-commit",
|
||||
"char_id", selectedCharacterID,
|
||||
"progress", progress,
|
||||
"granted", delivery.Granted,
|
||||
"reason", "current_exe_op143_reward_response_invalid",
|
||||
"error", err)
|
||||
return nil
|
||||
}
|
||||
itemIDs := make([]uint32, 0, len(delivery.Rows))
|
||||
slots := make([]uint16, 0, len(delivery.Rows))
|
||||
counts := make([]uint32, 0, len(delivery.Rows))
|
||||
for _, row := range delivery.Rows {
|
||||
itemIDs = append(itemIDs, row.ItemID)
|
||||
slots = append(slots, row.Slot)
|
||||
counts = append(counts, row.Count)
|
||||
}
|
||||
s.logGameEvent(session, "game-dungeon-tutorial-reward-op143-ack-send",
|
||||
"char_id", selectedCharacterID,
|
||||
"dungeon_id", runtime.Dungeon.ID,
|
||||
"room", snapshot.Run.Current.String(),
|
||||
"map_id", snapshot.Scene.Map.Map.ID,
|
||||
"progress", progress,
|
||||
"msg_id", uint16(dnfenum.CmdPacketChangeTutorialFlag),
|
||||
"classification", 1,
|
||||
"success", 1,
|
||||
"reward_count", len(delivery.Rows),
|
||||
"item_ids", itemIDs,
|
||||
"slots", slots,
|
||||
"counts", counts,
|
||||
"new_grant", delivery.Granted,
|
||||
"body_len", len(payload)+1,
|
||||
"body_source", "current_exe_sub_33C4A20_u8_count_then_u16_slot_u32_item_u32_count",
|
||||
"asset_owner", "character_assets_uow",
|
||||
"reward_source", currentDungeonTutorialRewardPVFPath+"_["+currentDungeonTutorialRewardSection+"]")
|
||||
return s.sendGameUpperSuccess(
|
||||
session,
|
||||
uint16(dnfenum.CmdPacketChangeTutorialFlag),
|
||||
payload,
|
||||
)
|
||||
}
|
||||
|
||||
func (s *Service) resolveCurrentDungeonTutorialRewards(progress uint32) ([]currentDungeonTutorialRewardDefinition, error) {
|
||||
monsterCatalog, err := s.dungeonMonsterCatalog()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
rewardCatalog, err := newPVFDungeonTutorialRewardCatalog(monsterCatalog.source)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
rewards := rewardCatalog.Rewards(progress)
|
||||
if len(rewards) == 0 {
|
||||
return nil, fmt.Errorf("%w: progress=%d", errDungeonTutorialRewardMissing, progress)
|
||||
}
|
||||
definitions := make([]currentDungeonTutorialRewardDefinition, 0, len(rewards))
|
||||
for _, reward := range rewards {
|
||||
definition, err := resolveCurrentDungeonTutorialRewardItem(monsterCatalog.source, reward.ItemID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if !isCurrentDungeonTutorialConsumable(definition.StackableType) {
|
||||
return nil, fmt.Errorf(
|
||||
"%w: progress=%d item=%d stackable_type=%q",
|
||||
errDungeonTutorialRewardItemInvalid,
|
||||
progress,
|
||||
reward.ItemID,
|
||||
definition.StackableType,
|
||||
)
|
||||
}
|
||||
if definition.StackLimit > 0 && uint64(reward.Count) > uint64(definition.StackLimit) {
|
||||
return nil, fmt.Errorf(
|
||||
"%w: progress=%d item=%d count=%d stack_limit=%d",
|
||||
errDungeonTutorialRewardItemInvalid,
|
||||
progress,
|
||||
reward.ItemID,
|
||||
reward.Count,
|
||||
definition.StackLimit,
|
||||
)
|
||||
}
|
||||
definitions = append(definitions, currentDungeonTutorialRewardDefinition{Reward: reward, Item: definition})
|
||||
}
|
||||
return definitions, nil
|
||||
}
|
||||
|
||||
func resolveCurrentDungeonTutorialRewardItem(
|
||||
source dnfpvf.Source,
|
||||
itemID uint32,
|
||||
) (currentDungeonTutorialRewardItemDefinition, error) {
|
||||
if source == nil || itemID == 0 {
|
||||
return currentDungeonTutorialRewardItemDefinition{}, errDungeonTutorialRewardSourceRequired
|
||||
}
|
||||
text, err := source.ReadText(currentDungeonTutorialStackableList)
|
||||
if err != nil {
|
||||
return currentDungeonTutorialRewardItemDefinition{}, fmt.Errorf("read %s: %w", currentDungeonTutorialStackableList, err)
|
||||
}
|
||||
document, err := dnfpvf.Parse(currentDungeonTutorialStackableList, text)
|
||||
if err != nil {
|
||||
return currentDungeonTutorialRewardItemDefinition{}, fmt.Errorf("parse %s: %w", currentDungeonTutorialStackableList, err)
|
||||
}
|
||||
listedPath := ""
|
||||
for _, entry := range dnfpvf.ParseList(document) {
|
||||
if entry.ID == int64(itemID) {
|
||||
listedPath = cleanCurrentDungeonTutorialRewardPath(entry.Path)
|
||||
break
|
||||
}
|
||||
}
|
||||
if listedPath == "" {
|
||||
return currentDungeonTutorialRewardItemDefinition{}, fmt.Errorf(
|
||||
"%w: item=%d absent_from=%s",
|
||||
errDungeonTutorialRewardItemInvalid,
|
||||
itemID,
|
||||
currentDungeonTutorialStackableList,
|
||||
)
|
||||
}
|
||||
candidates := []string{listedPath}
|
||||
if !strings.HasPrefix(strings.ToLower(listedPath), "stackable/") {
|
||||
candidates = append(candidates, path.Join("stackable", listedPath))
|
||||
}
|
||||
var itemPath string
|
||||
var itemText string
|
||||
var lastErr error
|
||||
for _, candidate := range candidates {
|
||||
itemText, lastErr = source.ReadText(candidate)
|
||||
if lastErr == nil {
|
||||
itemPath = candidate
|
||||
break
|
||||
}
|
||||
}
|
||||
if itemPath == "" {
|
||||
return currentDungeonTutorialRewardItemDefinition{}, fmt.Errorf(
|
||||
"read tutorial reward item=%d path=%s: %w",
|
||||
itemID,
|
||||
listedPath,
|
||||
lastErr,
|
||||
)
|
||||
}
|
||||
itemDocument, err := dnfpvf.Parse(itemPath, itemText)
|
||||
if err != nil {
|
||||
return currentDungeonTutorialRewardItemDefinition{}, fmt.Errorf(
|
||||
"parse tutorial reward item=%d path=%s: %w",
|
||||
itemID,
|
||||
itemPath,
|
||||
err,
|
||||
)
|
||||
}
|
||||
stackableType, _ := itemDocument.Text("stackable type")
|
||||
definition := currentDungeonTutorialRewardItemDefinition{
|
||||
ItemID: itemID,
|
||||
PVFPath: itemPath,
|
||||
StackableType: stackableType,
|
||||
SlotStart: 65,
|
||||
SlotEnd: 120,
|
||||
}
|
||||
if limit, found := itemDocument.Int("stack limit"); found && limit > 0 {
|
||||
definition.StackLimit = limit
|
||||
}
|
||||
expirationDate, err := parseCurrentPVFExpirationDate(itemDocument)
|
||||
if err != nil {
|
||||
return currentDungeonTutorialRewardItemDefinition{}, fmt.Errorf("parse tutorial reward item=%d path=%s expiration date: %w", itemID, itemPath, err)
|
||||
}
|
||||
definition.ExpirationDate = expirationDate
|
||||
return definition, nil
|
||||
}
|
||||
|
||||
func cleanCurrentDungeonTutorialRewardPath(value string) string {
|
||||
value = strings.TrimSpace(strings.ReplaceAll(value, "\\", "/"))
|
||||
value = strings.TrimPrefix(value, "./")
|
||||
return strings.TrimPrefix(value, "/")
|
||||
}
|
||||
|
||||
func isCurrentDungeonTutorialConsumable(stackableType string) bool {
|
||||
normalized := strings.ToLower(strings.TrimSpace(strings.ReplaceAll(stackableType, "`", "")))
|
||||
return strings.HasPrefix(normalized, "[waste]")
|
||||
}
|
||||
|
||||
func deliverCurrentDungeonTutorialReward(
|
||||
ctx context.Context,
|
||||
uow dnfrepo.CharacterAssetUnitOfWork,
|
||||
characterID string,
|
||||
progress uint32,
|
||||
definitions []currentDungeonTutorialRewardDefinition,
|
||||
now time.Time,
|
||||
) (currentDungeonTutorialRewardDelivery, error) {
|
||||
if uow == nil || strings.TrimSpace(characterID) == "" || progress == 0 || len(definitions) == 0 {
|
||||
return currentDungeonTutorialRewardDelivery{}, errDungeonTutorialRewardAssetMissing
|
||||
}
|
||||
owner, err := dnfdungeon.NewOwner(dnfrepo.Group{CharacterAssets: uow})
|
||||
if err != nil {
|
||||
return currentDungeonTutorialRewardDelivery{}, errDungeonTutorialRewardAssetMissing
|
||||
}
|
||||
rewards := make([]dnfdungeon.TutorialItemReward, 0, len(definitions))
|
||||
for _, definition := range definitions {
|
||||
rewards = append(rewards, currentDungeonTutorialDomainReward(definition))
|
||||
}
|
||||
result, err := owner.GrantTutorialReward(ctx, dnfdungeon.TutorialRewardCommand{
|
||||
CharacterID: characterID,
|
||||
Progress: progress,
|
||||
Rewards: rewards,
|
||||
UpdatedAt: now,
|
||||
Project: func(stack dnfrepo.ItemStack, expiration time.Time) (dnfrepo.ItemStack, error) {
|
||||
stack, _ = applyCurrentStackableExpirationAt(stack, expiration, now)
|
||||
return stack, nil
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
return currentDungeonTutorialRewardDelivery{}, mapCurrentDungeonTutorialOwnerError(err)
|
||||
}
|
||||
delivery := currentDungeonTutorialRewardDelivery{Granted: result.Granted}
|
||||
for _, row := range result.Rows {
|
||||
delivery.Rows = append(delivery.Rows, currentDungeonTutorialRewardRow{
|
||||
Slot: row.Slot, ItemID: row.ItemID, Count: row.Count,
|
||||
})
|
||||
}
|
||||
return delivery, nil
|
||||
}
|
||||
|
||||
func currentDungeonTutorialRewardMarker(progress uint32) string {
|
||||
return dnfdungeon.TutorialRewardMarker(progress)
|
||||
}
|
||||
|
||||
func addCurrentDungeonTutorialRewardToInventory(
|
||||
record *dnfrepo.InventoryRecord,
|
||||
progress uint32,
|
||||
definition currentDungeonTutorialRewardDefinition,
|
||||
) (int16, error) {
|
||||
reward := currentDungeonTutorialDomainReward(definition)
|
||||
slot, err := dnfdungeon.PlaceTutorialReward(
|
||||
record,
|
||||
progress,
|
||||
reward,
|
||||
func(stack dnfrepo.ItemStack, expiration time.Time) (dnfrepo.ItemStack, error) {
|
||||
stack, _ = applyCurrentStackableExpiration(stack, expiration)
|
||||
return stack, nil
|
||||
},
|
||||
)
|
||||
if err != nil {
|
||||
return 0, mapCurrentDungeonTutorialOwnerError(err)
|
||||
}
|
||||
return int16(slot), nil
|
||||
}
|
||||
|
||||
func currentDungeonTutorialDomainReward(
|
||||
definition currentDungeonTutorialRewardDefinition,
|
||||
) dnfdungeon.TutorialItemReward {
|
||||
return dnfdungeon.TutorialItemReward{
|
||||
Progress: definition.Reward.Progress,
|
||||
ItemID: definition.Reward.ItemID,
|
||||
Count: definition.Reward.Count,
|
||||
Consumable: definition.Item.ItemID == definition.Reward.ItemID &&
|
||||
isCurrentDungeonTutorialConsumable(definition.Item.StackableType),
|
||||
StackLimit: definition.Item.StackLimit,
|
||||
SlotStart: definition.Item.SlotStart,
|
||||
SlotEnd: definition.Item.SlotEnd,
|
||||
ExpireAt: definition.Item.ExpirationDate,
|
||||
PVFPath: definition.Item.PVFPath,
|
||||
StackableType: definition.Item.StackableType,
|
||||
}
|
||||
}
|
||||
|
||||
func mapCurrentDungeonTutorialOwnerError(err error) error {
|
||||
switch {
|
||||
case errors.Is(err, dnfdungeon.ErrOwnerUnavailable),
|
||||
errors.Is(err, dnfdungeon.ErrTutorialAssetsMissing):
|
||||
return errDungeonTutorialRewardAssetMissing
|
||||
case errors.Is(err, dnfdungeon.ErrTutorialInventoryFull):
|
||||
return fmt.Errorf("%w: %v", errDungeonTutorialRewardInventoryFull, err)
|
||||
case errors.Is(err, dnfdungeon.ErrTutorialRewardInvalid),
|
||||
errors.Is(err, dnfdungeon.ErrStackProjectorRequired):
|
||||
return fmt.Errorf("%w: %v", errDungeonTutorialRewardItemInvalid, err)
|
||||
default:
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
func currentDungeonTutorialMainSlotKey(slot int16) string {
|
||||
return "0:" + strconv.FormatInt(int64(slot), 10)
|
||||
}
|
||||
|
||||
func buildCurrentDungeonTutorialRewardSuccessPayload(rows []currentDungeonTutorialRewardRow) ([]byte, error) {
|
||||
if len(rows) > math.MaxUint8 {
|
||||
return nil, fmt.Errorf("%w: reward_count=%d", errDungeonTutorialRewardResponse, len(rows))
|
||||
}
|
||||
var writer packetWriter
|
||||
writer.writeByte(byte(len(rows)))
|
||||
for index, row := range rows {
|
||||
if row.Slot == 0 || row.ItemID == 0 || row.Count == 0 {
|
||||
return nil, fmt.Errorf(
|
||||
"%w: row=%d slot=%d item=%d count=%d",
|
||||
errDungeonTutorialRewardResponse,
|
||||
index,
|
||||
row.Slot,
|
||||
row.ItemID,
|
||||
row.Count,
|
||||
)
|
||||
}
|
||||
writer.writeUint16(row.Slot)
|
||||
writer.writeUint32(row.ItemID)
|
||||
writer.writeUint32(row.Count)
|
||||
}
|
||||
return writer.bytes(), nil
|
||||
}
|
||||
Reference in new issue
Block a user