《MMO 服务器开发》7.3 保底机制与掉落审计

// file: internal/loot/pity.go
// tier: L1
// verify: go test ./internal/loot/
package loot

import "math/rand/v2"

// PityTracker 实现「硬保底」：连续 Threshold 次没出稀有，第 Threshold 次强制出。
//
// 它只维护计数，不碰任何随机数，所以可以被单独单测，也方便存档与回档。
type PityTracker struct {
	Threshold uint32
	misses    uint32
}

// NewPity 构造一个硬保底计数器；Threshold 为 0 表示不保底。
func NewPity(threshold uint32) *PityTracker {
	return &PityTracker{Threshold: threshold}
}

// Resolve 在自然抽取结果之上叠加保底判定。
//
// naturalRare 为真表示本次自然抽中稀有；返回 forcedRare 为真表示本次是
// 保底强制产出（此时自然结果按未中处理）。两种情况都会清零计数。
func (p *PityTracker) Resolve(naturalRare bool) (forcedRare bool) {
	if naturalRare {
		p.misses = 0
		return false
	}
	if p.Threshold == 0 {
		return false
	}
	p.misses++
	if p.misses >= p.Threshold {
		p.misses = 0
		return true
	}
	return false
}

// Misses 返回当前连续未出稀有的次数。
func (p *PityTracker) Misses() uint32 { return p.misses }

// SoftPity 实现「软保底」：次数越接近硬保底，稀有概率被抬得越高。
//
// 硬保底给的是「最多等多久」的上界，软保底给的是「越等越容易出」的手感。
// 两者叠加后，期望抽取次数显著低于纯硬保底，但最坏情况仍被封死。
type SoftPity struct {
	Start    uint32  // 从第 Start 次未中开始抬概率
	Hard     uint32  // 硬保底次数；达到即强制出
	BaseRate float64 // 起始概率
	MaxRate  float64 // 抬升上限
	misses   uint32
}

// Rate 返回当前这一次的稀有概率（不含硬保底强制）。
func (s *SoftPity) Rate() float64 {
	if s.misses < s.Start {
		return s.BaseRate
	}
	span := float64(s.Hard) - float64(s.Start)
	if span <= 0 {
		return s.MaxRate
	}
	t := float64(s.misses-s.Start) / span
	r := s.BaseRate + t*(s.MaxRate-s.BaseRate)
	if r > s.MaxRate {
		return s.MaxRate
	}
	if r < s.BaseRate {
		return s.BaseRate
	}
	return r
}

// Roll 用该实体的独立 PRNG 做一次软保底判定。
func (s *SoftPity) Roll(r *rand.Rand) (rare bool) {
	if s.Hard > 0 && s.misses+1 >= s.Hard {
		s.misses = 0
		return true
	}
	if r.Float64() < s.Rate() {
		s.misses = 0
		return true
	}
	s.misses++
	return false
}

// Misses 返回当前连续未出稀有的次数。
func (s *SoftPity) Misses() uint32 { return s.misses }

// file: internal/loot/audit.go
// tier: L1
// verify: go test ./internal/loot/
package loot

import (
	"encoding/binary"
	"hash/fnv"
)

// AuditRecord 是一次掉落结算的可复算凭证。
//
// 有了 Player + Batch + Seed 就能重放出同样的掉落；Digest 是结果的指纹，
// 用来和重放结果比对；Prev/Chain 把记录串成一条哈希链，任何一条被改都会断链。
type AuditRecord struct {
	Batch  uint64 // 掉落批次序号
	Player uint64 // 玩家ID
	SeedHi uint64 // 复算用的 PCG 种子高位
	SeedLo uint64 // 复算用的 PCG 种子低位
	Digest uint64 // 掉落结果指纹
	Prev   uint64 // 上一条记录的链哈希
	Chain  uint64 // 本条记录的链哈希
}

// AuditLog 是内存里的追加式哈希链。
type AuditLog struct {
	records []AuditRecord
	head    uint64
}

// Append 记录一次掉落并返回写入的记录。
func (l *AuditLog) Append(player, batch uint64, seed SeedPair, drops []Drop) AuditRecord {
	rec := AuditRecord{
		Batch:  batch,
		Player: player,
		SeedHi: seed.Hi,
		SeedLo: seed.Lo,
		Digest: DigestDrops(drops),
		Prev:   l.head,
	}
	rec.Chain = chainHash(rec)
	l.head = rec.Chain
	l.records = append(l.records, rec)
	return rec
}

// Records 返回链上的全部记录（只读用途）。
func (l *AuditLog) Records() []AuditRecord { return l.records }

// Head 返回当前链尾哈希。
func (l *AuditLog) Head() uint64 { return l.head }

// Verify 从头重算整条链，任一条被篡改或次序被调换都会返回 false。
func (l *AuditLog) Verify() bool {
	var prev uint64
	for _, rec := range l.records {
		if rec.Prev != prev {
			return false
		}
		if chainHash(rec) != rec.Chain {
			return false
		}
		prev = rec.Chain
	}
	return prev == l.head
}

// DigestDrops 把掉落结果压成一个 64 位指纹。
//
// 结果必须已按 ItemID 排序（Table.Roll 保证），否则指纹会随遍历顺序抖动。
func DigestDrops(drops []Drop) uint64 {
	h := fnv.New64a()
	var b [8]byte
	for _, d := range drops {
		binary.BigEndian.PutUint32(b[0:4], uint32(d.ItemID))
		binary.BigEndian.PutUint32(b[4:8], d.Count)
		_, _ = h.Write(b[:])
	}
	return h.Sum64()
}

func chainHash(rec AuditRecord) uint64 {
	var b [40]byte
	binary.BigEndian.PutUint64(b[0:8], rec.Prev)
	binary.BigEndian.PutUint64(b[8:16], rec.Player)
	binary.BigEndian.PutUint64(b[16:24], rec.Batch)
	binary.BigEndian.PutUint64(b[24:32], rec.SeedHi)
	binary.BigEndian.PutUint64(b[32:40], rec.SeedLo)
	h := fnv.New64a()
	_, _ = h.Write(b[:])
	var d [8]byte
	binary.BigEndian.PutUint64(d[:], rec.Digest)
	_, _ = h.Write(d[:])
	return h.Sum64()
}