《游戏服务端编程实践》7.2.2 地图阻挡与通行数据

// file: ch07/path/block.go
// tier: L1
// verify: go test ./ch07/path/

package path

import "errors"

var (
	ErrInvalidSize      = errors.New("block: invalid grid size")
	ErrInvalidSource    = errors.New("block: source id required")
	ErrDuplicateBlocker = errors.New("block: source already registered")
	ErrUnknownBlocker   = errors.New("block: source not registered")
)

// BlockGrid 把阻挡拆成静态地形层和动态占位层。
// 静态层由地图数据一次性写入，动态层按来源（建筑、单位、临时法术）增删。
// 同一个格子可以被多个来源同时占用，只有全部撤销后才恢复可通行。
type BlockGrid struct {
	width    int
	height   int
	static   []bool
	dynamic  []int32
	sources  map[uint64][]Point
	revision uint64
}

func NewBlockGrid(width, height int) (*BlockGrid, error) {
	if width <= 0 || height <= 0 {
		return nil, ErrInvalidSize
	}
	n := width * height
	return &BlockGrid{
		width:   width,
		height:  height,
		static:  make([]bool, n),
		dynamic: make([]int32, n),
		sources: make(map[uint64][]Point),
	}, nil
}

func (b *BlockGrid) Width() int  { return b.width }
func (b *BlockGrid) Height() int { return b.height }

// Revision 在静态层或动态层每次变化后递增，供寻路缓存判断是否失效。
func (b *BlockGrid) Revision() uint64 { return b.revision }

func (b *BlockGrid) InBounds(p Point) bool {
	return p.X >= 0 && p.Y >= 0 && p.X < b.width && p.Y < b.height
}

func (b *BlockGrid) index(p Point) int { return p.Y*b.width + p.X }

// Static 报告静态地形是否阻挡；越界按阻挡处理。
func (b *BlockGrid) Static(p Point) bool {
	if !b.InBounds(p) {
		return true
	}
	return b.static[b.index(p)]
}

// Dynamic 返回该格当前的动态阻挡计数；越界返回 0。
func (b *BlockGrid) Dynamic(p Point) int32 {
	if !b.InBounds(p) {
		return 0
	}
	return b.dynamic[b.index(p)]
}

// Blocked 是寻路使用的最终判定：静态层或任意动态来源阻挡，越界也算阻挡。
func (b *BlockGrid) Blocked(p Point) bool {
	if !b.InBounds(p) {
		return true
	}
	i := b.index(p)
	return b.static[i] || b.dynamic[i] > 0
}

// Cost 让 BlockGrid 直接满足 Grid 接口，统一成本为 1。
func (b *BlockGrid) Cost(p Point) (float64, bool) {
	if b.Blocked(p) {
		return 0, false
	}
	return 1, true
}

func (b *BlockGrid) MinCost() float64 { return 1 }

func (b *BlockGrid) SetStatic(p Point, blocked bool) error {
	if !b.InBounds(p) {
		return ErrOutOfBounds
	}
	i := b.index(p)
	if b.static[i] == blocked {
		return nil
	}
	b.static[i] = blocked
	b.revision++
	return nil
}

// AddBlocker 注册一个动态来源占用的格子集合。整批校验通过后才生效，
// 不会出现一半格子已写入、一半报错的状态。
func (b *BlockGrid) AddBlocker(source uint64, cells []Point) error {
	if source == 0 {
		return ErrInvalidSource
	}
	if _, exists := b.sources[source]; exists {
		return ErrDuplicateBlocker
	}
	unique := make([]Point, 0, len(cells))
	seen := make(map[Point]struct{}, len(cells))
	for _, p := range cells {
		if !b.InBounds(p) {
			return ErrOutOfBounds
		}
		if _, dup := seen[p]; dup {
			continue
		}
		seen[p] = struct{}{}
		unique = append(unique, p)
	}
	for _, p := range unique {
		b.dynamic[b.index(p)]++
	}
	b.sources[source] = unique
	b.revision++
	return nil
}

// RemoveBlocker 撤销一个来源的全部占位。其他来源仍占用同一格时保持阻挡。
func (b *BlockGrid) RemoveBlocker(source uint64) error {
	cells, ok := b.sources[source]
	if !ok {
		return ErrUnknownBlocker
	}
	for _, p := range cells {
		i := b.index(p)
		if b.dynamic[i] > 0 {
			b.dynamic[i]--
		}
	}
	delete(b.sources, source)
	b.revision++
	return nil
}

// ClearDynamic 在副本回滚、赛季重置或地图重载时清空所有动态层。
func (b *BlockGrid) ClearDynamic() {
	if len(b.sources) == 0 {
		return
	}
	clear(b.dynamic)
	clear(b.sources)
	b.revision++
}

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

ok  	gspractice/ch07/path	0.262s