《游戏服务端编程实践》8.2.3 战斗日志与回放

// file: ch08/skill/replay.go
// tier: L1
// verify: go test ./ch08/skill/

package skill

import (
	"errors"
	"fmt"
	"math/rand"
	"sort"
)

const replayVersion = 1

var (
	ErrReplayVersion = errors.New("unsupported replay version")
	ErrReplayEvent   = errors.New("invalid replay event")
	ErrRecorderDone  = errors.New("recorder already finished")
)

type EventType string

const (
	EventAttack EventType = "attack"
	EventHeal   EventType = "heal"
)

type Unit struct {
	ID     uint64 `json:"id"`
	HP     int    `json:"hp"`
	MaxHP  int    `json:"max_hp"`
	Attack int    `json:"attack"`
	Dead   bool   `json:"dead"`
}

// Event 只记录输入：谁在什么帧对谁做了什么，不记录伤害结果。
type Event struct {
	Frame  uint64    `json:"frame"`
	Seq    uint64    `json:"seq"`
	Type   EventType `json:"type"`
	Actor  uint64    `json:"actor"`
	Target uint64    `json:"target"`
	Amount int       `json:"amount"`
}

// Rules 随录像一起落盘，回放不读取线上当前配置。
type Rules struct {
	CritPercent    int `json:"crit_percent"`
	CritMultiplier int `json:"crit_multiplier"`
}

type Recording struct {
	Version int     `json:"version"`
	Seed    uint64  `json:"seed"`
	Rules   Rules   `json:"rules"`
	Units   []Unit  `json:"units"`
	Events  []Event `json:"events"`
}

type BattleState struct {
	Units  []Unit
	Frame  uint64
	Events int
}

type Recorder struct {
	seed   uint64
	rules  Rules
	units  []Unit
	events []Event
	seq    uint64
	closed bool
}

func NewRecorder(seed uint64, rules Rules, units []Unit) *Recorder {
	if rules.CritMultiplier <= 0 {
		rules.CritMultiplier = 2
	}
	if rules.CritPercent < 0 {
		rules.CritPercent = 0
	}
	if rules.CritPercent > 100 {
		rules.CritPercent = 100
	}
	return &Recorder{seed: seed, rules: rules, units: append([]Unit(nil), units...)}
}

func (r *Recorder) Record(ev Event) error {
	if r.closed {
		return ErrRecorderDone
	}
	if ev.Type != EventAttack && ev.Type != EventHeal {
		return fmt.Errorf("%w: unknown type %q", ErrReplayEvent, ev.Type)
	}
	if ev.Actor == 0 || ev.Target == 0 || ev.Amount <= 0 {
		return fmt.Errorf("%w: actor/target/amount", ErrReplayEvent)
	}
	r.seq++
	ev.Seq = r.seq
	r.events = append(r.events, ev)
	return nil
}

// Finish 冻结录像，并按帧号、到达序号排序后返回。
func (r *Recorder) Finish() Recording {
	r.closed = true
	events := append([]Event(nil), r.events...)
	sort.Slice(events, func(i, j int) bool {
		if events[i].Frame != events[j].Frame {
			return events[i].Frame < events[j].Frame
		}
		return events[i].Seq < events[j].Seq
	})
	return Recording{
		Version: replayVersion,
		Seed:    r.seed,
		Rules:   r.rules,
		Units:   append([]Unit(nil), r.units...),
		Events:  events,
	}
}

// Replay 用录像中的种子和规则重新执行输入，得到与录制时一致的状态。
func Replay(rec Recording) (*BattleState, error) {
	if rec.Version != replayVersion {
		return nil, fmt.Errorf("%w: %d", ErrReplayVersion, rec.Version)
	}
	units := append([]Unit(nil), rec.Units...)
	index := make(map[uint64]int, len(units))
	for i := range units {
		if units[i].ID == 0 {
			return nil, fmt.Errorf("%w: zero unit id", ErrReplayEvent)
		}
		if _, ok := index[units[i].ID]; ok {
			return nil, fmt.Errorf("%w: duplicate unit %d", ErrReplayEvent, units[i].ID)
		}
		index[units[i].ID] = i
	}
	events := append([]Event(nil), rec.Events...)
	sort.Slice(events, func(i, j int) bool {
		if events[i].Frame != events[j].Frame {
			return events[i].Frame < events[j].Frame
		}
		return events[i].Seq < events[j].Seq
	})
	rng := rand.New(rand.NewSource(int64(rec.Seed)))
	state := &BattleState{Units: units}
	for _, ev := range events {
		// 每条事件固定消耗一次随机数，死亡跳过也不改变后续序列。
		roll := rng.Intn(100)
		ai, ok := index[ev.Actor]
		if !ok {
			return nil, fmt.Errorf("%w: actor %d", ErrReplayEvent, ev.Actor)
		}
		ti, ok := index[ev.Target]
		if !ok {
			return nil, fmt.Errorf("%w: target %d", ErrReplayEvent, ev.Target)
		}
		state.Frame = ev.Frame
		if state.Units[ai].Dead {
			continue
		}
		switch ev.Type {
		case EventAttack:
			dmg := ev.Amount
			if roll < rec.Rules.CritPercent {
				dmg *= rec.Rules.CritMultiplier
			}
			if dmg < 0 {
				dmg = 0
			}
			state.Units[ti].HP -= dmg
			if state.Units[ti].HP <= 0 {
				state.Units[ti].HP = 0
				state.Units[ti].Dead = true
			}
		case EventHeal:
			if state.Units[ti].Dead {
				continue
			}
			state.Units[ti].HP += ev.Amount
			if state.Units[ti].HP > state.Units[ti].MaxHP {
				state.Units[ti].HP = state.Units[ti].MaxHP
			}
		}
		state.Events++
	}
	return state, nil
}

cd .local/checks/gs-practice-lab && gofmt -l ch08/skill && go vet ./ch08/skill/ && go test ./ch08/skill/ -count=1

ok  	gspractice/ch08/skill	0.293s