hanfuit
645b64fe21
服务端（Go）： - GM 塞背包/带属性装备发放：在线角色推送 op14 增量物品行，背包实时刷新，无需回角色选择界面 - GM 改金币/改等级：去掉在线拒绝，落库后推送 op14 钱包/op37 等级状态，在线实时刷新 - 等级端点统一切换到新版 GMSetCharacterLevel（自带在线刷新） - 无限/锁死疲劳模式 + 燃烧疲劳：每房间消耗 2 点、打怪与通关经验双倍 - 燃烧疲劳开关时给所有在线角色推送系统提示（op12 mode 0） - 深渊史诗掉率：GM 全局倍率 + 城镇增益药剂窗口倍率，真实接入掉落结算 启动器（Python/JS）： - 标题栏自绘、窗口 1204x717、禁止拖拽改大小、仅最小化/关闭 - GM 工具：疲劳与燃烧、深渊史诗掉率、拍卖行上架（单一定价对齐） - 拍卖行上架前端对齐服务端单一价格语义，修复 400 报错
393 lines
17 KiB
Go
393 lines
17 KiB
Go
package dnfbridge
|
|
|
|
import (
|
|
"context"
|
|
"encoding/binary"
|
|
"errors"
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"longheng.io/server/internal/modules/dnf/alignedcmd"
|
|
"longheng.io/server/internal/modules/dnf/dnfenum"
|
|
"longheng.io/server/internal/modules/dnf/premium"
|
|
dnfproto "longheng.io/server/internal/modules/dnf/protocol"
|
|
dnfrepo "longheng.io/server/internal/modules/dnf/repository"
|
|
)
|
|
|
|
const currentPremiumServiceBlobSize = 74
|
|
|
|
func premiumGameplayModule() gameplayModuleDefinition {
|
|
serviceOpcode := uint16(dnfenum.CmdPacketPremiumService)
|
|
recoverOpcode := uint16(dnfenum.CmdPacketRecoverStamina)
|
|
crystalUpdateOpcode := uint16(dnfenum.CmdPacketUpdateContractOfCubeInfo)
|
|
crystalConsumeOpcode := uint16(dnfenum.CmdPacketUseLimitCube)
|
|
serviceHandler := func(service *Service, session *gameSession, request gameplayRequest) error {
|
|
return service.handleCurrentPremiumService(session, request.Body)
|
|
}
|
|
crystalUpdateHandler := func(service *Service, session *gameSession, request gameplayRequest) error {
|
|
return service.handleCurrentCrystalContractUpdate(session, request.Body)
|
|
}
|
|
crystalConsumeHandler := func(service *Service, session *gameSession, request gameplayRequest) error {
|
|
return service.handleCurrentLimitedCubeUseRequest(session, request.Body)
|
|
}
|
|
recoverHandler := func(service *Service, session *gameSession, request gameplayRequest) error {
|
|
return service.handleCurrentPremiumFreeWeakness(session, request.Body)
|
|
}
|
|
return gameplayModuleDefinition{
|
|
Name: "premium-service",
|
|
LegacyHandlers: map[uint16]gameplayHandler{
|
|
serviceOpcode: serviceHandler,
|
|
// The 解除虚弱 NPC button sends op9 on the legacy path
|
|
// (cmd=1 type=9). Registering it only under UpperHandlers meant
|
|
// the request was received, logged and then dropped with no
|
|
// dispatch at all -- the NPC simply did nothing, and no
|
|
// weakness-recovery event was ever written.
|
|
recoverOpcode: recoverHandler,
|
|
crystalUpdateOpcode: crystalUpdateHandler,
|
|
crystalConsumeOpcode: crystalConsumeHandler,
|
|
},
|
|
UpperHandlers: map[uint16]gameplayHandler{
|
|
serviceOpcode: func(service *Service, session *gameSession, request gameplayRequest) error {
|
|
if !requireDefaultGameplayClassification(
|
|
service,
|
|
session,
|
|
request,
|
|
"game-premium-service-request-blocked",
|
|
"current_exe_op903_command_class_mismatch",
|
|
) {
|
|
return nil
|
|
}
|
|
return serviceHandler(service, session, request)
|
|
},
|
|
recoverOpcode: func(service *Service, session *gameSession, request gameplayRequest) error {
|
|
if !requireDefaultGameplayClassification(
|
|
service,
|
|
session,
|
|
request,
|
|
"game-premium-free-weakness-blocked",
|
|
"current_exe_op9_command_class_mismatch",
|
|
) {
|
|
return nil
|
|
}
|
|
return recoverHandler(service, session, request)
|
|
},
|
|
crystalUpdateOpcode: defaultClassGameplayHandler(
|
|
"game-crystal-contract-selection-request-blocked",
|
|
"current_exe_op535_command_class_mismatch",
|
|
func(service *Service, session *gameSession, body []byte) error {
|
|
return crystalUpdateHandler(service, session, gameplayRequest{Body: body})
|
|
},
|
|
),
|
|
crystalConsumeOpcode: defaultClassGameplayHandler(
|
|
"game-limit-cube-use-request-blocked",
|
|
"current_exe_op338_command_class_mismatch",
|
|
func(service *Service, session *gameSession, body []byte) error {
|
|
return crystalConsumeHandler(service, session, gameplayRequest{Body: body})
|
|
},
|
|
),
|
|
},
|
|
}
|
|
}
|
|
|
|
func (s *Service) handleCurrentPremiumService(session *gameSession, body []byte) error {
|
|
// Current EXE action 1 carries a 74-byte blob. sub_206A240 sends slot 3
|
|
// when the seven-buff service is actually applied; account for that daily
|
|
// use before returning the complete authoritative state.
|
|
if len(body) >= 2+currentPremiumServiceBlobSize && binary.LittleEndian.Uint16(body[:2]) == 1 {
|
|
slot := int64(binary.LittleEndian.Uint16(body[2:4]))
|
|
if slot == premium.DevilSlotSevenBuff {
|
|
if err := s.consumeCurrentPremiumServiceDaily(session, slot, s.gameplayNow()); err != nil {
|
|
s.logGameEvent(session, "game-premium-service-use-blocked",
|
|
"slot", slot,
|
|
"reason", err)
|
|
}
|
|
}
|
|
}
|
|
return s.sendCurrentPremiumServiceState(session, "op903_request", currentPremiumServiceTypeForSession(session))
|
|
}
|
|
|
|
// handleCurrentPremiumFreeWeakness answers op9, the 解除虚弱状态 NPC action
|
|
// (etc/popupmenu.etc entry 48).
|
|
//
|
|
// The client's u16 says which button was pressed - NoPack sub_30C6B10 sends 1
|
|
// for the 魔王契约 route and 0 for the paid one - but it is a request, not a
|
|
// verdict. The server decides whether the contract is active, whether its daily
|
|
// quota remains, and whether the gold is there; the previous implementation
|
|
// spent the quota purely because the client had asked, and cleared nothing.
|
|
//
|
|
// The answer shape is the current EXE's own: sub_1D11820 reads [ebp+0xC] as the
|
|
// status byte and, on success, calls the condition setter (vtable+0xAD4) with
|
|
// 100 - the only write of that value anywhere in the binary. The failure branch
|
|
// sub_1D11900 reads [ebp+0x10] as a reason code and decodes 0x12 (no weakness)
|
|
// and 0x16 (cannot afford) into their own messages.
|
|
func (s *Service) handleCurrentPremiumFreeWeakness(session *gameSession, body []byte) error {
|
|
if session == nil || session.selectedCharacterID == 0 {
|
|
return nil
|
|
}
|
|
useContract := len(body) >= 2 && binary.LittleEndian.Uint16(body[:2]) == 1
|
|
// The gameplay clock, not the wall clock: the daily quota, the contract
|
|
// expiry and the weakness write must all agree on "now".
|
|
now := s.gameplayNow()
|
|
|
|
character, err := s.currentWeaknessCharacter(session)
|
|
if err != nil {
|
|
s.logGameEvent(session, "game-weakness-recovery-blocked", "reason", err)
|
|
return s.sendGameUpperFailure(session, uint16(dnfenum.CmdPacketRecoverStamina), currentWeaknessReasonNotWeakened)
|
|
}
|
|
level := currentWeaknessLevel(character)
|
|
if level == 0 {
|
|
s.logGameEvent(session, "game-weakness-recovery-refused",
|
|
"char_id", session.selectedCharacterID,
|
|
"requested_contract", useContract,
|
|
"reason_code", currentWeaknessReasonNotWeakened,
|
|
"reason", "character_is_not_weakened")
|
|
return s.sendGameUpperFailure(session, uint16(dnfenum.CmdPacketRecoverStamina), currentWeaknessReasonNotWeakened)
|
|
}
|
|
|
|
if useContract {
|
|
// Server-side verdict: active contract plus remaining daily quota, and
|
|
// the quota is spent only when the clear actually happens below.
|
|
if err := s.consumeCurrentPremiumServiceDaily(session, premium.DevilSlotFreeWeakness, now); err != nil {
|
|
s.logGameEvent(session, "game-weakness-recovery-refused",
|
|
"char_id", session.selectedCharacterID,
|
|
"slot", premium.DevilSlotFreeWeakness,
|
|
"reason_code", currentWeaknessReasonCannotAfford,
|
|
"reason", err)
|
|
return s.sendGameUpperFailure(session, uint16(dnfenum.CmdPacketRecoverStamina), currentWeaknessReasonCannotAfford)
|
|
}
|
|
if _, _, _, err := s.clearCurrentWeakness(session, 0); err != nil {
|
|
s.logGameEvent(session, "game-weakness-recovery-blocked", "reason", err)
|
|
return s.sendGameUpperFailure(session, uint16(dnfenum.CmdPacketRecoverStamina), currentWeaknessReasonCannotAfford)
|
|
}
|
|
s.logGameEvent(session, "game-weakness-recovery-committed",
|
|
"char_id", session.selectedCharacterID,
|
|
"route", "devil_contract_slot5",
|
|
"exemption", string(currentWeaknessExemptionDevilSlot),
|
|
"cleared_level", level,
|
|
"gold_cost", 0)
|
|
if err := s.sendGameUpperSuccess(session, uint16(dnfenum.CmdPacketRecoverStamina), nil); err != nil {
|
|
return err
|
|
}
|
|
// The success ACK clears the weakness UI but says nothing about the
|
|
// contract; without this the panel keeps showing the pre-use count.
|
|
return s.sendCurrentPremiumServiceState(session, "devil_contract_free_weakness_after_op9", currentPremiumServiceTypeForSession(session))
|
|
}
|
|
|
|
cost := int64(0)
|
|
if table, tableErr := s.currentWeaknessCostTable(); tableErr == nil {
|
|
cost = table.recoveryCost(level, int64(character.Level))
|
|
} else {
|
|
s.logGameEvent(session, "game-weakness-recovery-cost-unavailable", "reason", tableErr)
|
|
}
|
|
clearedLevel, remainingGold, goldSource, err := s.clearCurrentWeakness(session, cost)
|
|
if err != nil {
|
|
reason := currentWeaknessReasonCannotAfford
|
|
if errors.Is(err, errCurrentWeaknessNotWeakened) {
|
|
reason = currentWeaknessReasonNotWeakened
|
|
}
|
|
s.logGameEvent(session, "game-weakness-recovery-refused",
|
|
"char_id", session.selectedCharacterID,
|
|
"gold_cost", cost,
|
|
"reason_code", reason,
|
|
"reason", err)
|
|
return s.sendGameUpperFailure(session, uint16(dnfenum.CmdPacketRecoverStamina), reason)
|
|
}
|
|
s.logGameEvent(session, "game-weakness-recovery-committed",
|
|
"char_id", session.selectedCharacterID,
|
|
"route", "gold",
|
|
"cleared_level", clearedLevel,
|
|
"gold_cost", cost,
|
|
"gold_after", remainingGold,
|
|
"gold_source", string(goldSource))
|
|
if err := s.sendGameUpperSuccess(session, uint16(dnfenum.CmdPacketRecoverStamina), nil); err != nil {
|
|
return err
|
|
}
|
|
if cost > 0 {
|
|
// The wallet is main-list slot 0, but on this server it is projected
|
|
// from the character's gold column, so an incremental refresh of that
|
|
// slot resolves nothing. Push the wallet the way every other gold
|
|
// spender does. Only a payment that really came out of the legacy
|
|
// inventory row needs that row re-sent instead.
|
|
if goldSource == currentWeaknessGoldSourceLegacySlot {
|
|
return s.sendSelectedIncrementalItemSlotRefreshes(session, "weakness_recovery_gold", []alignedcmd.ItemSlotRefresh{{
|
|
ListType: dnfrepo.MainInventoryListType,
|
|
SlotIndex: 0,
|
|
}})
|
|
}
|
|
return s.sendSelectedMainWalletsRefresh(session, "weakness_recovery_gold")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *Service) currentWeaknessCharacter(session *gameSession) (dnfrepo.CharacterRecord, error) {
|
|
repositories, ok := s.repositoryGroup()
|
|
if !ok || repositories.Character == nil {
|
|
return dnfrepo.CharacterRecord{}, errCurrentWeaknessUnavailable
|
|
}
|
|
ctx, cancel := context.WithTimeout(context.Background(), createWriteTimeout)
|
|
defer cancel()
|
|
character, found, err := repositories.Character.Load(ctx, strconv.Itoa(int(session.selectedCharacterID)))
|
|
if err != nil {
|
|
return dnfrepo.CharacterRecord{}, err
|
|
}
|
|
if !found {
|
|
return dnfrepo.CharacterRecord{}, errCurrentWeaknessUnavailable
|
|
}
|
|
return character, nil
|
|
}
|
|
|
|
func (s *Service) currentPremiumServiceRecords(
|
|
ctx context.Context,
|
|
session *gameSession,
|
|
) (dnfrepo.Group, dnfrepo.AccountRecord, dnfrepo.CharacterRecord, error) {
|
|
repositories, ok := s.repositoryGroup()
|
|
if !ok || repositories.Account == nil || repositories.Character == nil {
|
|
return dnfrepo.Group{}, dnfrepo.AccountRecord{}, dnfrepo.CharacterRecord{}, fmt.Errorf("premium repositories are unavailable")
|
|
}
|
|
if session == nil || session.selectedCharacterID == 0 {
|
|
return dnfrepo.Group{}, dnfrepo.AccountRecord{}, dnfrepo.CharacterRecord{}, fmt.Errorf("premium selected character is missing")
|
|
}
|
|
accountID := strings.TrimSpace(s.accountIDForSession(session))
|
|
characterID := strconv.Itoa(int(session.selectedCharacterID))
|
|
account, found, err := repositories.Account.Load(ctx, accountID)
|
|
if err != nil {
|
|
return dnfrepo.Group{}, dnfrepo.AccountRecord{}, dnfrepo.CharacterRecord{}, fmt.Errorf("load premium account: %w", err)
|
|
}
|
|
if !found {
|
|
return dnfrepo.Group{}, dnfrepo.AccountRecord{}, dnfrepo.CharacterRecord{}, fmt.Errorf("premium account %q is missing", accountID)
|
|
}
|
|
character, found, err := repositories.Character.Load(ctx, characterID)
|
|
if err != nil {
|
|
return dnfrepo.Group{}, dnfrepo.AccountRecord{}, dnfrepo.CharacterRecord{}, fmt.Errorf("load premium character: %w", err)
|
|
}
|
|
if !found || strings.TrimSpace(character.AccountID) != accountID {
|
|
return dnfrepo.Group{}, dnfrepo.AccountRecord{}, dnfrepo.CharacterRecord{}, fmt.Errorf("premium character ownership mismatch")
|
|
}
|
|
return repositories, account, character, nil
|
|
}
|
|
|
|
func (s *Service) consumeCurrentPremiumServiceDaily(session *gameSession, slot int64, now time.Time) error {
|
|
ctx, cancel := context.WithTimeout(context.Background(), createWriteTimeout)
|
|
defer cancel()
|
|
repositories, ok := s.repositoryGroup()
|
|
if !ok || repositories.Account == nil || repositories.CharacterAssets == nil {
|
|
return fmt.Errorf("premium account/character transaction is unavailable")
|
|
}
|
|
if session == nil || session.selectedCharacterID == 0 {
|
|
return fmt.Errorf("premium selected character is missing")
|
|
}
|
|
accountID := strings.TrimSpace(s.accountIDForSession(session))
|
|
characterID := strconv.Itoa(int(session.selectedCharacterID))
|
|
account, found, err := repositories.Account.Load(ctx, accountID)
|
|
if err != nil {
|
|
return fmt.Errorf("load premium account: %w", err)
|
|
}
|
|
if !found {
|
|
return fmt.Errorf("premium account %q is missing", accountID)
|
|
}
|
|
if !premium.Active(account, premium.DevilSlotType(slot), now) {
|
|
return fmt.Errorf("premium slot %d is inactive", slot)
|
|
}
|
|
return repositories.CharacterAssets.WithinCharacterAssets(
|
|
ctx,
|
|
characterID,
|
|
func(
|
|
characters dnfrepo.CharacterRepository,
|
|
_ dnfrepo.InventoryRepository,
|
|
_ dnfrepo.EquipmentRepository,
|
|
) error {
|
|
character, characterFound, loadErr := characters.Load(ctx, characterID)
|
|
if loadErr != nil {
|
|
return fmt.Errorf("load premium character: %w", loadErr)
|
|
}
|
|
if !characterFound || strings.TrimSpace(character.AccountID) != accountID {
|
|
return fmt.Errorf("premium character ownership mismatch")
|
|
}
|
|
if !premium.TryConsumeDaily(&character, slot, now) {
|
|
return fmt.Errorf("premium slot %d daily limit %d reached", slot, premium.DailyLimit(slot))
|
|
}
|
|
return dnfrepo.SaveCharacterFields(ctx, characters, character, dnfrepo.CharacterFieldStats)
|
|
},
|
|
)
|
|
}
|
|
|
|
// currentPremiumServiceTypeForSession picks the op903 serviceType for a send that
|
|
// is NOT the login/entry scene tail.
|
|
//
|
|
// serviceType 1 makes the client apply the body to the contract singleton its UI
|
|
// reads and, while its own one-shot "show the contract panel" flag is still
|
|
// armed, open that panel (handler 0x01CFE1D0 -> 0x01CFE2AA). The flag is armed by
|
|
// the client's class1/op4 SELECT_CHARACTER handler and cleared by the first type-1
|
|
// body, so the intended flow is exactly one type-1 send per login: the scene
|
|
// tail's. A session whose tail never ran must not answer with 1, or the panel
|
|
// pops wherever the first such answer lands -- live 2026-09-16T14:23:54Z on conn
|
|
// game-000209 the tail stayed deferred ("wait_for_current_exe_legacy_type1345_u32_2_scene_ready")
|
|
// and an in-dungeon op903 request popped the panel. After the tail consumed the
|
|
// flag, 1 is safe again and keeps the contract UI data fresh.
|
|
func currentPremiumServiceTypeForSession(session *gameSession) uint16 {
|
|
if session != nil && session.premiumPanelFlagConsumed.Load() {
|
|
return premium.ServiceTypePanel
|
|
}
|
|
return premium.ServiceTypeSilent
|
|
}
|
|
|
|
func (s *Service) sendCurrentPremiumServiceState(session *gameSession, source string, serviceType uint16) error {
|
|
ctx, cancel := context.WithTimeout(context.Background(), createWriteTimeout)
|
|
defer cancel()
|
|
repositories, ok := s.repositoryGroup()
|
|
if !ok || repositories.Account == nil || repositories.Character == nil {
|
|
return fmt.Errorf("premium repositories are unavailable")
|
|
}
|
|
accountID := strings.TrimSpace(s.accountIDForSession(session))
|
|
account, found, err := repositories.Account.Load(ctx, accountID)
|
|
if err != nil {
|
|
return fmt.Errorf("load premium account state: %w", err)
|
|
}
|
|
if !found {
|
|
account = dnfrepo.AccountRecord{}
|
|
}
|
|
character := dnfrepo.CharacterRecord{}
|
|
if session != nil && session.selectedCharacterID != 0 {
|
|
characterID := strconv.Itoa(int(session.selectedCharacterID))
|
|
loaded, characterFound, loadErr := repositories.Character.Load(ctx, characterID)
|
|
if loadErr != nil {
|
|
return fmt.Errorf("load premium character state: %w", loadErr)
|
|
}
|
|
if characterFound {
|
|
if strings.TrimSpace(loaded.AccountID) != accountID {
|
|
return fmt.Errorf("premium character ownership mismatch")
|
|
}
|
|
character = loaded
|
|
}
|
|
}
|
|
// The gameplay clock, not the wall clock: the service-day bucket this body
|
|
// reports usage against has to be the same one consumeCurrentPremiumServiceDaily
|
|
// wrote into, or every fresh use reads back as unused.
|
|
now := s.gameplayNow()
|
|
body := buildCurrentPremiumServiceDataBody(account, character, now, serviceType)
|
|
s.logGameEvent(session, "game-premium-service-state-send",
|
|
"source", source,
|
|
"msg_id", uint16(dnfenum.CmdPacketPremiumService),
|
|
"classification", dnfproto.DefaultChannelClassification,
|
|
"body_len", len(body),
|
|
"service_type", serviceType,
|
|
"slot_count", premium.DevilSlotCount,
|
|
"state_source", "account_expiry_and_character_service_day_usage")
|
|
if err := s.sendGameUpperRawClass(
|
|
session,
|
|
uint16(dnfenum.CmdPacketPremiumService),
|
|
body,
|
|
dnfproto.DefaultChannelClassification,
|
|
); err != nil {
|
|
return err
|
|
}
|
|
if serviceType == premium.ServiceTypePanel && session != nil {
|
|
// The client clears its one-shot panel flag on this body, so every later
|
|
// type-1 send can no longer open the contract panel.
|
|
session.premiumPanelFlagConsumed.Store(true)
|
|
}
|
|
return nil
|
|
}
|