《游戏服务端编程实践》20.3 战斗与调度系统

// file: ch20/march/march.go
// tier: L1
// verify: go test ./ch20/march/

package march

import (
	"errors"
	"fmt"
	"hash/fnv"
	"math/rand"
	"sort"
	"time"
)

const (
	StateMarching  = "marching"
	StateArrived   = "arrived"
	StateCancelled = "cancelled"
)

var (
	ErrNotArrived    = errors.New("march: not arrived yet")
	ErrCancelled     = errors.New("march: cancelled")
	ErrCannotCancel  = errors.New("march: cannot cancel")
	ErrNotDeparted   = errors.New("march: not departed yet")
	ErrSettled       = errors.New("march: already settled")
	ErrDuplicateID   = errors.New("march: duplicate march id")
	ErrInvalidMarch  = errors.New("march: invalid march")
	ErrInvalidTroops = errors.New("march: invalid troops")
)

// Defense 是防守方在结算时提供的快照，避免结算过程中再读世界状态。
type Defense struct {
	Troops   int
	BonusPct int
}

// Report 是服务端权威结算结果。Seed 必须落库，方便客服复现和申诉。
type Report struct {
	MarchID      string
	Owner        uint64
	Winner       string
	AttackerLoss int
	DefenderLoss int
	Seed         uint64
	SettledAt    time.Time
}

// March 只保留调度需要的字段。ArriveAt 是权威到达时间，
// 是否已经结算由 report 是否为 nil 判断，而不是依赖内存定时器。
type March struct {
	ID       string
	Owner    uint64
	From     string
	To       string
	Troops   int
	BonusPct int
	DepartAt time.Time
	ArriveAt time.Time
	State    string
	seed     uint64
	report   *Report
}

func New(id string, owner uint64, from, to string, troops int, departAt time.Time, travel time.Duration, seed uint64) (*March, error) {
	if id == "" {
		return nil, fmt.Errorf("%w: empty id", ErrInvalidMarch)
	}
	if troops <= 0 {
		return nil, ErrInvalidTroops
	}
	if travel < 0 {
		return nil, ErrInvalidTroops
	}
	return &March{
		ID:       id,
		Owner:    owner,
		From:     from,
		To:       to,
		Troops:   troops,
		DepartAt: departAt,
		ArriveAt: departAt.Add(travel),
		State:    StateMarching,
		seed:     seed,
	}, nil
}

// Report 返回已经落库的结算结果，第二个返回值表示是否已结算。
func (m *March) Report() (Report, bool) {
	if m.report == nil {
		return Report{}, false
	}
	return *m.report, true
}

// Settle 按到达时间做惰性结算，重复调用返回同一份报告，不会重新掷随机数。
func (m *March) Settle(now time.Time, d Defense) (Report, error) {
	if m.report != nil {
		return *m.report, nil
	}
	if m.State == StateCancelled {
		return Report{}, ErrCancelled
	}
	if now.Before(m.ArriveAt) {
		return Report{}, fmt.Errorf("%w: arrive at %s", ErrNotArrived,
			m.ArriveAt.UTC().Format(time.RFC3339))
	}
	rep := m.resolve(now, d)
	m.report = &rep
	m.State = StateArrived
	return rep, nil
}

func (m *March) resolve(now time.Time, d Defense) Report {
	seed := m.seed
	if seed == 0 {
		h := fnv.New64a()
		_, _ = h.Write([]byte(m.ID))
		seed = h.Sum64()
	}
	rng := rand.New(rand.NewSource(int64(seed)))
	swing := 90 + rng.Intn(21)
	atkPower := power(m.Troops, m.BonusPct) * swing / 100
	defPower := power(d.Troops, d.BonusPct)
	winner := "defender"
	atkLoss, defLoss := m.Troops, 0
	switch {
	case atkPower > defPower:
		winner = "attacker"
		atkLoss = m.Troops * defPower / (atkPower + defPower)
		defLoss = d.Troops
	case defPower > 0:
		defLoss = d.Troops * atkPower / (atkPower + defPower)
	}
	return Report{
		MarchID:      m.ID,
		Owner:        m.Owner,
		Winner:       winner,
		AttackerLoss: atkLoss,
		DefenderLoss: defLoss,
		Seed:         seed,
		SettledAt:    now,
	}
}

// power 把兵力和百分比加成换算成整数战力，至少保留 1 点，避免除零。
func power(troops, bonusPct int) int {
	if troops <= 0 {
		return 0
	}
	if bonusPct < -100 {
		bonusPct = -100
	}
	if p := troops * (100 + bonusPct) / 100; p > 0 {
		return p
	}
	return 1
}

// SpeedUp 缩短行军时间，最早只能到达 now，避免加速把到达时间推到出发之前。
func (m *March) SpeedUp(now time.Time, d time.Duration) error {
	if m.report != nil {
		return ErrSettled
	}
	if m.State == StateCancelled {
		return ErrCancelled
	}
	if now.Before(m.DepartAt) {
		return ErrNotDeparted
	}
	if d <= 0 {
		return nil
	}
	arrive := m.ArriveAt.Add(-d)
	if arrive.Before(now) {
		arrive = now
	}
	if arrive.Before(m.DepartAt) {
		arrive = m.DepartAt
	}
	m.ArriveAt = arrive
	return nil
}

// Cancel 只在行军途中有效，到达后必须先结算。返还的兵力由调用方写回部队账本。
func (m *March) Cancel(now time.Time) (int, error) {
	if m.report != nil {
		return 0, ErrSettled
	}
	if m.State == StateCancelled {
		return 0, ErrCannotCancel
	}
	if now.Before(m.DepartAt) {
		return 0, ErrNotDeparted
	}
	if !now.Before(m.ArriveAt) {
		return 0, fmt.Errorf("%w: arrival reached, settle first", ErrCannotCancel)
	}
	m.State = StateCancelled
	return m.Troops, nil
}

// Scheduler 不持有一个行军一个定时器，而是把到期行军集中在一个 Tick 里结算。
type Scheduler struct {
	marches map[string]*March
}

func NewScheduler() *Scheduler {
	return &Scheduler{marches: make(map[string]*March)}
}

func (s *Scheduler) Add(m *March) error {
	if m == nil || m.ID == "" {
		return ErrInvalidMarch
	}
	if _, ok := s.marches[m.ID]; ok {
		return fmt.Errorf("%w: %s", ErrDuplicateID, m.ID)
	}
	s.marches[m.ID] = m
	return nil
}

// Due 返回已经到点但尚未结算的行军，按到达时间和 ID 排序，保证结算顺序稳定。
func (s *Scheduler) Due(now time.Time) []*March {
	due := make([]*March, 0)
	for _, m := range s.marches {
		if m.State != StateMarching {
			continue
		}
		if !now.Before(m.ArriveAt) {
			due = append(due, m)
		}
	}
	sort.Slice(due, func(i, j int) bool {
		if !due[i].ArriveAt.Equal(due[j].ArriveAt) {
			return due[i].ArriveAt.Before(due[j].ArriveAt)
		}
		return due[i].ID < due[j].ID
	})
	return due
}

// Tick 结算所有到点行军。防守数据由调用方按目标点批量查好，
// 结算函数本身不访问数据库，保证同一次 Tick 的输入稳定。
func (s *Scheduler) Tick(now time.Time, defense func(*March) Defense) ([]Report, error) {
	reports := make([]Report, 0)
	for _, m := range s.Due(now) {
		d := Defense{}
		if defense != nil {
			d = defense(m)
		}
		rep, err := m.Settle(now, d)
		if err != nil {
			return nil, fmt.Errorf("march: tick %s: %w", m.ID, err)
		}
		reports = append(reports, rep)
	}
	return reports, nil
}

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

ok  	gspractice/ch20/march	0.451s