《游戏服务端编程实践》20.2 资源产出与建筑系统

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

package building

import (
	"errors"
	"fmt"
	"time"
)

const (
	// BasePerHour 是一级建筑每小时的基础产出，示例值，实际由配置表决定。
	BasePerHour = 60
	// MaxLevel 是示例等级上限。
	MaxLevel = 30
)

var (
	ErrTimeBackwards = errors.New("building: time moved backwards")
	ErrNotEnough     = errors.New("building: not enough resource")
	ErrQueueBusy     = errors.New("building: upgrade queue busy")
	ErrMaxLevel      = errors.New("building: max level reached")
	ErrPrerequisite  = errors.New("building: prerequisite not met")
)

type Resource string

const (
	Wood  Resource = "wood"
	Stone Resource = "stone"
	Iron  Resource = "iron"
)

// Cost 是升级消耗。使用 map 便于配置表扩展，比较和扣减都要先全部检查再写入，
// 避免扣到一半失败。
type Cost map[Resource]int

func (c Cost) Total() int {
	total := 0
	for _, n := range c {
		total += n
	}
	return total
}

// Storage 是玩家资源账户。所有读写都在服务端完成。
type Storage struct {
	amounts map[Resource]int
}

func NewStorage(initial map[Resource]int) *Storage {
	s := &Storage{amounts: make(map[Resource]int, len(initial))}
	for r, n := range initial {
		if n > 0 {
			s.amounts[r] = n
		}
	}
	return s
}

func (s *Storage) Amount(r Resource) int { return s.amounts[r] }

// Deduct 是原子操作：先检查全部资源，再统一扣减。
func (s *Storage) Deduct(c Cost) error {
	for r, n := range c {
		if s.amounts[r] < n {
			return fmt.Errorf("%w: %s need %d have %d", ErrNotEnough, r, n, s.amounts[r])
		}
	}
	for r, n := range c {
		s.amounts[r] -= n
		if s.amounts[r] == 0 {
			delete(s.amounts, r)
		}
	}
	return nil
}

// Building 只保存产出相关状态。升级中的产出仍按当前等级结算，
// 升级完成时才切换等级，避免一次升级把整段离线时间按新等级补发。
type Building struct {
	ID          string
	Level       int
	BonusPct    int
	Prereq      string
	PrereqLevel int
	Stored      int
	LastTick    time.Time
}

// RatePerHour 使用整数百分比，避免浮点误差导致同一段时间在不同机器上算出不同结果。
func (b *Building) RatePerHour() int {
	if b.Level <= 0 {
		return 0
	}
	return BasePerHour * b.Level * (100 + b.BonusPct) / 100
}

// Produce 结算 LastTick 到 now 的产出，并把结算点推进到已经兑现的那一秒。
// 达到上限后把 LastTick 直接推进到 now，否则玩家收走资源后会把溢出的时段重新补发。
func (b *Building) Produce(now time.Time, cap int) (int, error) {
	if now.Before(b.LastTick) {
		return 0, fmt.Errorf("%w: last=%s now=%s", ErrTimeBackwards,
			b.LastTick.UTC().Format(time.RFC3339), now.UTC().Format(time.RFC3339))
	}
	if cap < 0 {
		return 0, fmt.Errorf("building: negative cap %d", cap)
	}
	if b.Level <= 0 {
		b.LastTick = now
		return 0, nil
	}
	rate := b.RatePerHour()
	if rate <= 0 {
		b.LastTick = now
		return 0, nil
	}
	seconds := int(now.Sub(b.LastTick) / time.Second)
	if seconds <= 0 {
		return 0, nil
	}
	raw := rate * seconds / 3600
	if raw <= 0 {
		return 0, nil
	}
	room := cap - b.Stored
	if room <= 0 {
		b.LastTick = now
		return 0, nil
	}
	if raw >= room {
		b.Stored = cap
		b.LastTick = now
		return room, nil
	}
	b.Stored += raw
	secured := raw * 3600 / rate
	b.LastTick = b.LastTick.Add(time.Duration(secured) * time.Second)
	return raw, nil
}

// UpgradeCost 返回升到目标等级的消耗，示例公式，实际按配置表读取。
func UpgradeCost(toLevel int) Cost {
	if toLevel < 2 {
		return nil
	}
	return Cost{Wood: 100 * toLevel, Stone: 50 * toLevel, Iron: 10 * toLevel}
}

// CanUpgrade 校验等级上限和前置建筑，前置建筑必须在同一份权威数据里。
func CanUpgrade(b *Building, all map[string]*Building) error {
	if b.Level >= MaxLevel {
		return fmt.Errorf("%w: level %d", ErrMaxLevel, b.Level)
	}
	if b.Prereq == "" {
		return nil
	}
	if p, ok := all[b.Prereq]; ok && p.Level >= b.PrereqLevel {
		return nil
	}
	return fmt.Errorf("%w: %s >= %d", ErrPrerequisite, b.Prereq, b.PrereqLevel)
}

// Upgrade 是一条升级队列项。Cost 在入队时已经扣除，取消时由业务层决定是否返还。
type Upgrade struct {
	BuildingID string
	ToLevel    int
	Cost       Cost
	StartedAt  time.Time
	FinishAt   time.Time
}

// Queue 用固定槽位限制并行升级。slots 为 1 时就是最常见的单队列。
type Queue struct {
	slots   int
	items   []Upgrade
	storage *Storage
}

func NewQueue(slots int, storage *Storage) *Queue {
	if slots < 1 {
		slots = 1
	}
	return &Queue{slots: slots, storage: storage}
}

func (q *Queue) Len() int   { return len(q.items) }
func (q *Queue) Full() bool { return len(q.items) >= q.slots }

// Enqueue 先检查队列空位，再扣资源。队列满时不扣资源，避免玩家白扣。
func (q *Queue) Enqueue(u Upgrade) error {
	if q.Full() {
		return fmt.Errorf("%w: %d/%d", ErrQueueBusy, len(q.items), q.slots)
	}
	if q.storage != nil {
		if err := q.storage.Deduct(u.Cost); err != nil {
			return err
		}
	}
	q.items = append(q.items, u)
	return nil
}

// SpeedUp 缩短指定建筑的升级时间，最早只能完成到 now。
func (q *Queue) SpeedUp(buildingID string, d time.Duration, now time.Time) bool {
	if d < 0 {
		return false
	}
	for i := range q.items {
		if q.items[i].BuildingID != buildingID {
			continue
		}
		finish := q.items[i].FinishAt.Add(-d)
		if finish.Before(now) {
			finish = now
		}
		if finish.Before(q.items[i].StartedAt) {
			finish = q.items[i].StartedAt
		}
		q.items[i].FinishAt = finish
		return true
	}
	return false
}

// Complete 取出已完成的升级并切到目标等级；未完成的保持原顺序。
func (q *Queue) Complete(now time.Time, all map[string]*Building) []Upgrade {
	done := make([]Upgrade, 0, len(q.items))
	keep := q.items[:0]
	for _, u := range q.items {
		if now.Before(u.FinishAt) {
			keep = append(keep, u)
			continue
		}
		if b, ok := all[u.BuildingID]; ok && b.Level < u.ToLevel {
			b.Level = u.ToLevel
		}
		done = append(done, u)
	}
	q.items = keep
	return done
}

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

ok  	gspractice/ch20/building	0.654s