hanfuit
645b64fe21
服务端（Go）： - GM 塞背包/带属性装备发放：在线角色推送 op14 增量物品行，背包实时刷新，无需回角色选择界面 - GM 改金币/改等级：去掉在线拒绝，落库后推送 op14 钱包/op37 等级状态，在线实时刷新 - 等级端点统一切换到新版 GMSetCharacterLevel（自带在线刷新） - 无限/锁死疲劳模式 + 燃烧疲劳：每房间消耗 2 点、打怪与通关经验双倍 - 燃烧疲劳开关时给所有在线角色推送系统提示（op12 mode 0） - 深渊史诗掉率：GM 全局倍率 + 城镇增益药剂窗口倍率，真实接入掉落结算 启动器（Python/JS）： - 标题栏自绘、窗口 1204x717、禁止拖拽改大小、仅最小化/关闭 - GM 工具：疲劳与燃烧、深渊史诗掉率、拍卖行上架（单一定价对齐） - 拍卖行上架前端对齐服务端单一价格语义，修复 400 报错
381 lines
12 KiB
Go
381 lines
12 KiB
Go
package drop
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"math"
|
|
|
|
dnfpvf "longheng.io/server/internal/modules/dnf/pvf"
|
|
)
|
|
|
|
const MonsterRulePath = "Etc/ItemDropInfo_Monseter.etc"
|
|
|
|
var (
|
|
ErrMonsterRuleSourceRequired = errors.New("dnf monster drop rule PVF source is required")
|
|
ErrMonsterRuleSectionMissing = errors.New("dnf monster drop rule PVF section is missing")
|
|
ErrMonsterRuleSectionShape = errors.New("dnf monster drop rule PVF section shape is invalid")
|
|
)
|
|
|
|
// MonsterProbabilityRow preserves one exact seven-column [drop prob] row.
|
|
// The first two values form the lookup range. The five remaining columns stay
|
|
// opaque until their category mapping is proved from the current server/EXE;
|
|
// the PVF section alone does not safely name them as gold/equipment/material.
|
|
type MonsterProbabilityRow struct {
|
|
KeyMin int64
|
|
KeyMax int64
|
|
Rates [5]int64
|
|
}
|
|
|
|
// MonsterItemReference preserves one exact three-column [item drop ref table]
|
|
// row. ValueA and ValueB are intentionally not named as grade offsets because
|
|
// that business meaning is not established by the PVF document itself.
|
|
type MonsterItemReference struct {
|
|
LookupKey int64
|
|
ValueA int64
|
|
ValueB int64
|
|
}
|
|
|
|
type MonsterRuleSnapshot struct {
|
|
ProbabilityRows int
|
|
RarityRows int
|
|
PartyBonusRows int
|
|
DifficultyBonusRows int
|
|
MonsterTypeRows int
|
|
ItemReferences int
|
|
ConditionRows int
|
|
}
|
|
|
|
// MonsterRawTables is a value-copy of the remaining fixed-size PVF sections.
|
|
// The names describe source sections and shape only; row/column category
|
|
// semantics are not promoted to business rules without separate evidence.
|
|
type MonsterRawTables struct {
|
|
RarityDecision [4][7]int64
|
|
PartyBonus [5][4]float64
|
|
DifficultyBonus [5][5]float64
|
|
MonsterTypeBonus [5][4]float64
|
|
FirstBossNamed [2]int64
|
|
ConditionRates [4][2]int64
|
|
GoldQuantity [4]int64
|
|
GoldVolume [2]int64
|
|
RarityControl [2][5]int64
|
|
}
|
|
|
|
// MonsterSourcePlan is a pure lookup result. It does not roll a probability,
|
|
// choose an item, allocate a scene object, or mutate an inventory.
|
|
type MonsterSourcePlan struct {
|
|
LookupKey int64
|
|
Probability MonsterProbabilityRow
|
|
ItemReference MonsterItemReference
|
|
ProbabilityFound bool
|
|
ItemReferenceFound bool
|
|
}
|
|
|
|
// MonsterRules is a read-only typed view of every numeric section currently
|
|
// present in ItemDropInfo_Monseter.etc. Matrices preserve PVF row/column order;
|
|
// their axes remain deliberately opaque where the current runtime has not
|
|
// proved a category mapping.
|
|
type MonsterRules struct {
|
|
probabilityRows []MonsterProbabilityRow
|
|
rarityDecision [4][7]int64
|
|
partyBonus [5][4]float64
|
|
difficultyBonus [5][5]float64
|
|
monsterTypeBonus [5][4]float64
|
|
itemReferences map[int64]MonsterItemReference
|
|
firstBossNamed [2]int64
|
|
conditionRates [4][2]int64
|
|
goldQuantity [4]int64
|
|
goldVolume [2]int64
|
|
rarityControl [2][5]int64
|
|
}
|
|
|
|
func LoadMonsterRules(source dnfpvf.Source) (*MonsterRules, error) {
|
|
if source == nil {
|
|
return nil, ErrMonsterRuleSourceRequired
|
|
}
|
|
text, err := source.ReadText(MonsterRulePath)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("read %s: %w", MonsterRulePath, err)
|
|
}
|
|
document, err := dnfpvf.Parse(MonsterRulePath, text)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("parse %s: %w", MonsterRulePath, err)
|
|
}
|
|
|
|
probabilityRows, err := parseMonsterProbabilityRows(document)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
itemReferences, err := parseMonsterItemReferences(document)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
rules := &MonsterRules{
|
|
probabilityRows: probabilityRows,
|
|
itemReferences: itemReferences,
|
|
}
|
|
if err := fillMonsterRuleIntMatrix(document, "basis of rarity dicision", 4, 7, func(row, column int, value int64) {
|
|
rules.rarityDecision[row][column] = value
|
|
}); err != nil {
|
|
return nil, err
|
|
}
|
|
for row := range rules.rarityDecision {
|
|
for column := 1; column < len(rules.rarityDecision[row]); column++ {
|
|
if rules.rarityDecision[row][column] < rules.rarityDecision[row][column-1] {
|
|
return nil, fmt.Errorf("%w: section=basis of rarity dicision row=%d column=%d value=%d previous=%d",
|
|
ErrMonsterRuleSectionShape, row, column, rules.rarityDecision[row][column], rules.rarityDecision[row][column-1])
|
|
}
|
|
}
|
|
}
|
|
if err := fillMonsterRuleNumberMatrix(document, "party member drop bonusrate", 5, 4, func(row, column int, value float64) {
|
|
rules.partyBonus[row][column] = value
|
|
}); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := fillMonsterRuleNumberMatrix(document, "dungeon difficulty drop bonusrate", 5, 5, func(row, column int, value float64) {
|
|
rules.difficultyBonus[row][column] = value
|
|
}); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := fillMonsterRuleNumberMatrix(document, "monster type drop bonusrate", 5, 4, func(row, column int, value float64) {
|
|
rules.monsterTypeBonus[row][column] = value
|
|
}); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := fillMonsterRuleIntArray(document, "first boss/named mob hunting", rules.firstBossNamed[:]); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := fillMonsterRuleIntMatrix(document, "condition rate", 4, 2, func(row, column int, value int64) {
|
|
rules.conditionRates[row][column] = value
|
|
}); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := fillMonsterRuleIntArray(document, "gold quantity", rules.goldQuantity[:]); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := fillMonsterRuleIntArray(document, "gold volume", rules.goldVolume[:]); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := fillMonsterRuleIntMatrix(document, "item drop rarity control", 2, 5, func(row, column int, value int64) {
|
|
rules.rarityControl[row][column] = value
|
|
}); err != nil {
|
|
return nil, err
|
|
}
|
|
return rules, nil
|
|
}
|
|
|
|
func parseMonsterProbabilityRows(document *dnfpvf.Document) ([]MonsterProbabilityRow, error) {
|
|
declared, found := document.Int("drop prob count")
|
|
if !found {
|
|
return nil, fmt.Errorf("%w: section=drop prob count", ErrMonsterRuleSectionMissing)
|
|
}
|
|
values, err := monsterRuleIntegers(document, "drop prob")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if declared <= 0 || len(values)%7 != 0 || int64(len(values)/7) != declared {
|
|
return nil, fmt.Errorf("%w: section=drop prob declared=%d values=%d row_width=7",
|
|
ErrMonsterRuleSectionShape, declared, len(values))
|
|
}
|
|
rows := make([]MonsterProbabilityRow, 0, len(values)/7)
|
|
for offset := 0; offset < len(values); offset += 7 {
|
|
row := MonsterProbabilityRow{
|
|
KeyMin: values[offset],
|
|
KeyMax: values[offset+1],
|
|
Rates: [5]int64{
|
|
values[offset+2], values[offset+3], values[offset+4], values[offset+5], values[offset+6],
|
|
},
|
|
}
|
|
if row.KeyMin < 0 || row.KeyMax < row.KeyMin {
|
|
return nil, fmt.Errorf("%w: section=drop prob row=%+v", ErrMonsterRuleSectionShape, row)
|
|
}
|
|
for _, value := range row.Rates {
|
|
if value < 0 {
|
|
return nil, fmt.Errorf("%w: section=drop prob row=%+v negative_rate=%d", ErrMonsterRuleSectionShape, row, value)
|
|
}
|
|
}
|
|
if len(rows) != 0 && row.KeyMin <= rows[len(rows)-1].KeyMax {
|
|
return nil, fmt.Errorf("%w: section=drop prob overlapping_or_unsorted previous=%+v current=%+v",
|
|
ErrMonsterRuleSectionShape, rows[len(rows)-1], row)
|
|
}
|
|
rows = append(rows, row)
|
|
}
|
|
return rows, nil
|
|
}
|
|
|
|
func parseMonsterItemReferences(document *dnfpvf.Document) (map[int64]MonsterItemReference, error) {
|
|
values, err := monsterRuleIntegers(document, "item drop ref table")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(values)%3 != 0 {
|
|
return nil, fmt.Errorf("%w: section=item drop ref table values=%d row_width=3", ErrMonsterRuleSectionShape, len(values))
|
|
}
|
|
rows := make(map[int64]MonsterItemReference, len(values)/3)
|
|
var previous int64
|
|
for offset := 0; offset < len(values); offset += 3 {
|
|
row := MonsterItemReference{LookupKey: values[offset], ValueA: values[offset+1], ValueB: values[offset+2]}
|
|
if row.LookupKey <= 0 || (offset != 0 && row.LookupKey <= previous) {
|
|
return nil, fmt.Errorf("%w: section=item drop ref table previous_key=%d row=%+v", ErrMonsterRuleSectionShape, previous, row)
|
|
}
|
|
rows[row.LookupKey] = row
|
|
previous = row.LookupKey
|
|
}
|
|
return rows, nil
|
|
}
|
|
|
|
func monsterRuleIntegers(document *dnfpvf.Document, section string) ([]int64, error) {
|
|
tokens, found := document.Section(section)
|
|
if !found {
|
|
return nil, fmt.Errorf("%w: section=%s", ErrMonsterRuleSectionMissing, section)
|
|
}
|
|
if len(tokens) == 0 {
|
|
return nil, fmt.Errorf("%w: section=%s empty", ErrMonsterRuleSectionShape, section)
|
|
}
|
|
values := make([]int64, 0, len(tokens))
|
|
for index, token := range tokens {
|
|
if token.Kind != dnfpvf.TokenInt {
|
|
return nil, fmt.Errorf("%w: section=%s token=%d kind=%s", ErrMonsterRuleSectionShape, section, index, token.Kind)
|
|
}
|
|
values = append(values, token.Int)
|
|
}
|
|
return values, nil
|
|
}
|
|
|
|
func monsterRuleNumbers(document *dnfpvf.Document, section string) ([]float64, error) {
|
|
tokens, found := document.Section(section)
|
|
if !found {
|
|
return nil, fmt.Errorf("%w: section=%s", ErrMonsterRuleSectionMissing, section)
|
|
}
|
|
if len(tokens) == 0 {
|
|
return nil, fmt.Errorf("%w: section=%s empty", ErrMonsterRuleSectionShape, section)
|
|
}
|
|
values := make([]float64, 0, len(tokens))
|
|
for index, token := range tokens {
|
|
var value float64
|
|
switch token.Kind {
|
|
case dnfpvf.TokenInt:
|
|
value = float64(token.Int)
|
|
case dnfpvf.TokenFloat:
|
|
value = token.Float
|
|
default:
|
|
return nil, fmt.Errorf("%w: section=%s token=%d kind=%s", ErrMonsterRuleSectionShape, section, index, token.Kind)
|
|
}
|
|
if math.IsNaN(value) || math.IsInf(value, 0) || value < 0 {
|
|
return nil, fmt.Errorf("%w: section=%s token=%d value=%v", ErrMonsterRuleSectionShape, section, index, value)
|
|
}
|
|
values = append(values, value)
|
|
}
|
|
return values, nil
|
|
}
|
|
|
|
func fillMonsterRuleIntArray(document *dnfpvf.Document, section string, destination []int64) error {
|
|
values, err := monsterRuleIntegers(document, section)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(values) != len(destination) {
|
|
return fmt.Errorf("%w: section=%s values=%d want=%d", ErrMonsterRuleSectionShape, section, len(values), len(destination))
|
|
}
|
|
copy(destination, values)
|
|
return nil
|
|
}
|
|
|
|
func fillMonsterRuleIntMatrix(
|
|
document *dnfpvf.Document,
|
|
section string,
|
|
rows int,
|
|
columns int,
|
|
set func(int, int, int64),
|
|
) error {
|
|
values, err := monsterRuleIntegers(document, section)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(values) != rows*columns {
|
|
return fmt.Errorf("%w: section=%s values=%d matrix=%dx%d", ErrMonsterRuleSectionShape, section, len(values), rows, columns)
|
|
}
|
|
for index, value := range values {
|
|
set(index/columns, index%columns, value)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func fillMonsterRuleNumberMatrix(
|
|
document *dnfpvf.Document,
|
|
section string,
|
|
rows int,
|
|
columns int,
|
|
set func(int, int, float64),
|
|
) error {
|
|
values, err := monsterRuleNumbers(document, section)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(values) != rows*columns {
|
|
return fmt.Errorf("%w: section=%s values=%d matrix=%dx%d", ErrMonsterRuleSectionShape, section, len(values), rows, columns)
|
|
}
|
|
for index, value := range values {
|
|
set(index/columns, index%columns, value)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (rules *MonsterRules) Probability(key int64) (MonsterProbabilityRow, bool) {
|
|
if rules == nil {
|
|
return MonsterProbabilityRow{}, false
|
|
}
|
|
for _, row := range rules.probabilityRows {
|
|
if key >= row.KeyMin && key <= row.KeyMax {
|
|
return row, true
|
|
}
|
|
}
|
|
return MonsterProbabilityRow{}, false
|
|
}
|
|
|
|
func (rules *MonsterRules) ItemReference(key int64) (MonsterItemReference, bool) {
|
|
if rules == nil {
|
|
return MonsterItemReference{}, false
|
|
}
|
|
row, found := rules.itemReferences[key]
|
|
return row, found
|
|
}
|
|
|
|
func (rules *MonsterRules) PlanSource(key int64) MonsterSourcePlan {
|
|
plan := MonsterSourcePlan{LookupKey: key}
|
|
plan.Probability, plan.ProbabilityFound = rules.Probability(key)
|
|
plan.ItemReference, plan.ItemReferenceFound = rules.ItemReference(key)
|
|
return plan
|
|
}
|
|
|
|
func (rules *MonsterRules) Snapshot() MonsterRuleSnapshot {
|
|
if rules == nil {
|
|
return MonsterRuleSnapshot{}
|
|
}
|
|
return MonsterRuleSnapshot{
|
|
ProbabilityRows: len(rules.probabilityRows),
|
|
RarityRows: len(rules.rarityDecision),
|
|
PartyBonusRows: len(rules.partyBonus),
|
|
DifficultyBonusRows: len(rules.difficultyBonus),
|
|
MonsterTypeRows: len(rules.monsterTypeBonus),
|
|
ItemReferences: len(rules.itemReferences),
|
|
ConditionRows: len(rules.conditionRates),
|
|
}
|
|
}
|
|
|
|
func (rules *MonsterRules) RawTables() MonsterRawTables {
|
|
if rules == nil {
|
|
return MonsterRawTables{}
|
|
}
|
|
return MonsterRawTables{
|
|
RarityDecision: rules.rarityDecision,
|
|
PartyBonus: rules.partyBonus,
|
|
DifficultyBonus: rules.difficultyBonus,
|
|
MonsterTypeBonus: rules.monsterTypeBonus,
|
|
FirstBossNamed: rules.firstBossNamed,
|
|
ConditionRates: rules.conditionRates,
|
|
GoldQuantity: rules.goldQuantity,
|
|
GoldVolume: rules.goldVolume,
|
|
RarityControl: rules.rarityControl,
|
|
}
|
|
}
|