《MMO 服务器开发》6.3 战斗结算与防重复发奖

// file: internal/combat/settlement.go
// tier: L1
// verify: go test ./internal/combat/ -run 'TestSettle|TestLedger' -v

package combat

import "sync"

// DamageEvent is one resolved hit produced by the cast pipeline.
type DamageEvent struct {
	Attacker EntityID
	Target   EntityID
	Skill    uint32
	Amount   int
	Tick     int64
}

// Actor is the minimal combat state the settlement needs: HP and live buffs.
type Actor struct {
	ID    EntityID
	HP    int
	MaxHP int
	Buffs BuffSet
}

// Settlement applies resolved hits and, on a kill, hands the reward to the
// ledger. It is the only place HP moves, so the scene loop can reason about
// combat as a pure function of the drained command order.
type Settlement struct {
	mu     sync.Mutex
	Actors map[EntityID]*Actor
	Ledger *RewardLedger
	Kills  int
}

// NewSettlement returns a settlement with an empty actor table.
func NewSettlement(ledger *RewardLedger) *Settlement {
	return &Settlement{Actors: make(map[EntityID]*Actor), Ledger: ledger}
}

// Add registers an actor.
func (s *Settlement) Add(a *Actor) {
	a.Buffs = *NewBuffSet()
	s.Actors[a.ID] = a
}

// Apply folds one hit into the target. It returns the target's HP after the hit
// and whether this hit was the killing blow. A hit against an already-dead actor
// is ignored (returns dead=false), which is how a late-arriving packet after
// death is neutralised without special-casing the network layer.
func (s *Settlement) Apply(ev DamageEvent) (hp int, dead bool) {
	s.mu.Lock()
	defer s.mu.Unlock()
	a := s.Actors[ev.Target]
	if a == nil || a.HP <= 0 {
		return 0, false
	}
	a.HP -= ev.Amount
	if a.HP > 0 {
		return a.HP, false
	}
	a.HP = 0
	s.Kills++
	return 0, true
}

// RewardCmd is the reward side of a kill. Battle+Drop is the business
// fingerprint; Seq is the transport sequence of the originating request and is
// carried only for logging and ordering, never for the dedup decision.
type RewardCmd struct {
	Battle uint64
	Drop   uint32
	Seq    uint32
	Amount int
}

// RewardLedger grants each (Battle, Drop) reward exactly once. It stands in for
// the persistent unique key described in volume 1: the key is the business
// fingerprint, not the transport Seq, so a retry that arrives with a fresh Seq
// still collapses to a single grant.
type RewardLedger struct {
	mu      sync.Mutex
	granted map[rewardKey]int
	total   int64
	deduped int64
}

type rewardKey struct {
	Battle uint64
	Drop   uint32
}

// NewRewardLedger returns an empty ledger.
func NewRewardLedger() *RewardLedger {
	return &RewardLedger{granted: make(map[rewardKey]int)}
}

// Apply credits the reward and returns the amount actually granted: the full
// Amount on first sight, 0 when the fingerprint was already granted.
func (l *RewardLedger) Apply(c RewardCmd) int {
	l.mu.Lock()
	defer l.mu.Unlock()
	k := rewardKey{Battle: c.Battle, Drop: c.Drop}
	if _, ok := l.granted[k]; ok {
		l.deduped++
		return 0
	}
	l.granted[k] = c.Amount
	l.total += int64(c.Amount)
	return c.Amount
}

// Granted reports whether a fingerprint has already been paid out.
func (l *RewardLedger) Granted(battle uint64, drop uint32) bool {
	l.mu.Lock()
	defer l.mu.Unlock()
	_, ok := l.granted[rewardKey{Battle: battle, Drop: drop}]
	return ok
}

// Stats returns the total credited amount and the number of deduped retries.
func (l *RewardLedger) Stats() (total, deduped int64) {
	l.mu.Lock()
	defer l.mu.Unlock()
	return l.total, l.deduped
}

// snippet: internal/combat/settlement_test.go（节选）

func TestSettleKillOnce(t *testing.T) {
	s := NewSettlement(NewRewardLedger())
	s.Add(&Actor{ID: 1, HP: 30, MaxHP: 30})

	hp, dead := s.Apply(DamageEvent{Attacker: 9, Target: 1, Skill: 1, Amount: 20})
	if dead || hp != 10 {
		t.Fatalf("first hit: hp=%d dead=%v, want 10/false", hp, dead)
	}
	_, dead = s.Apply(DamageEvent{Attacker: 9, Target: 1, Skill: 1, Amount: 20})
	if !dead {
		t.Fatal("killing blow not reported")
	}
	// A late packet against the corpse must not resurrect or re-kill it.
	if _, dead := s.Apply(DamageEvent{Attacker: 9, Target: 1, Skill: 1, Amount: 50}); dead {
		t.Fatal("hit on a dead actor was treated as a kill")
	}
	if s.Kills != 1 {
		t.Fatalf("kills = %d, want 1", s.Kills)
	}
}

func TestLedgerGrantsOncePerFingerprint(t *testing.T) {
	l := NewRewardLedger()
	if got := l.Apply(RewardCmd{Battle: 7, Drop: 1, Seq: 1, Amount: 100}); got != 100 {
		t.Fatalf("first grant = %d, want 100", got)
	}
	// Same fingerprint, new transport Seq: still exactly one grant.
	if got := l.Apply(RewardCmd{Battle: 7, Drop: 1, Seq: 2, Amount: 100}); got != 0 {
		t.Fatalf("duplicate grant = %d, want 0", got)
	}
	// A different drop in the same battle is a different reward.
	if got := l.Apply(RewardCmd{Battle: 7, Drop: 2, Seq: 3, Amount: 40}); got != 40 {
		t.Fatalf("second drop = %d, want 40", got)
	}
	total, deduped := l.Stats()
	if total != 140 || deduped != 1 {
		t.Fatalf("total=%d deduped=%d, want 140/1", total, deduped)
	}
	if !l.Granted(7, 1) || l.Granted(7, 9) {
		t.Fatal("Granted reported the wrong fingerprints")
	}
}