《游戏服务端编程实践》20.1 世界地图模块

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

package worldmap

import (
	"errors"
	"fmt"
	"sort"
)

const (
	// ChunkSize 是地块缓存的加载粒度。世界坐标先换算成块坐标，再按块载入。
	ChunkSize = 32
	// RegionSize 是跨服归属的划分粒度，必须能整除世界尺寸才便于对账。
	RegionSize = 256
)

var (
	ErrOutOfBounds = errors.New("worldmap: out of bounds")
	ErrTileBusy    = errors.New("worldmap: tile already owned")
	ErrNoOwner     = errors.New("worldmap: owner id must be positive")
)

// Coord 是大世界里的格坐标，原点在左上角，X 向右、Y 向下。
type Coord struct {
	X int
	Y int
}

func (c Coord) String() string { return fmt.Sprintf("(%d,%d)", c.X, c.Y) }

// Chunk 是缓存加载单位；Region 是跨服归属单位。
type Chunk struct {
	X int
	Y int
}

type Region struct {
	X int
	Y int
}

// Tile 只保存非默认状态。Kind 为空时按 "empty" 处理，避免为每块地存一份空结构。
type Tile struct {
	Coord Coord
	Owner uint64
	Level uint8
	Kind  string
}

// Free 表示地块没有归属，可以被占领。
func (t Tile) Free() bool { return t.Owner == 0 }

// Grid 用稀疏 map 保存已加载或已修改的地块。未加载的地块按空地处理，
// 这样大世界不需要一次性展开成 width*height 个对象。
type Grid struct {
	width  int
	height int
	tiles  map[Coord]Tile
}

func NewGrid(width, height int) (*Grid, error) {
	if width <= 0 || height <= 0 {
		return nil, fmt.Errorf("worldmap: invalid size %dx%d", width, height)
	}
	return &Grid{width: width, height: height, tiles: make(map[Coord]Tile)}, nil
}

func (g *Grid) InBounds(c Coord) bool {
	return c.X >= 0 && c.X < g.width && c.Y >= 0 && c.Y < g.height
}

// ChunkOf 与 RegionOf 只做整除换算，不校验边界：越界坐标也要能定位到块，
// 由加载函数决定裁剪还是拒绝。世界坐标按 0 基设计，负数一律拒绝。
func ChunkOf(c Coord) Chunk {
	return Chunk{X: c.X / ChunkSize, Y: c.Y / ChunkSize}
}

func RegionOf(c Coord) Region {
	return Region{X: c.X / RegionSize, Y: c.Y / RegionSize}
}

// LoadChunk 按需载入一个块，返回块内落在世界范围内的坐标。
// 重复调用是幂等的，已经加载过的块不会重复创建地块。
func (g *Grid) LoadChunk(ch Chunk) []Coord {
	if ch.X < 0 || ch.Y < 0 {
		return nil
	}
	x0, y0 := ch.X*ChunkSize, ch.Y*ChunkSize
	if x0 >= g.width || y0 >= g.height {
		return nil
	}
	x1, y1 := min(x0+ChunkSize, g.width), min(y0+ChunkSize, g.height)
	coords := make([]Coord, 0, (x1-x0)*(y1-y0))
	for y := y0; y < y1; y++ {
		for x := x0; x < x1; x++ {
			c := Coord{X: x, Y: y}
			if _, ok := g.tiles[c]; !ok {
				g.tiles[c] = Tile{Coord: c, Kind: "empty"}
			}
			coords = append(coords, c)
		}
	}
	return coords
}

// At 返回地块状态。越界返回 ErrOutOfBounds；未加载的合法坐标返回默认空地。
func (g *Grid) At(c Coord) (Tile, error) {
	if !g.InBounds(c) {
		return Tile{}, fmt.Errorf("%w: %s", ErrOutOfBounds, c)
	}
	if t, ok := g.tiles[c]; ok {
		return t, nil
	}
	return Tile{Coord: c, Kind: "empty"}, nil
}

// Set 写入地块状态；写入前必须校验坐标，防止坏数据污染快照。
func (g *Grid) Set(t Tile) error {
	if !g.InBounds(t.Coord) {
		return fmt.Errorf("%w: %s", ErrOutOfBounds, t.Coord)
	}
	if t.Kind == "" {
		t.Kind = "empty"
	}
	g.tiles[t.Coord] = t
	return nil
}

// Claim 占领空地。已归属的地块返回 ErrTileBusy，不会静默覆盖。
func (g *Grid) Claim(c Coord, owner uint64) error {
	if owner == 0 {
		return ErrNoOwner
	}
	t, err := g.At(c)
	if err != nil {
		return err
	}
	if !t.Free() {
		return fmt.Errorf("%w: %s owned by %d", ErrTileBusy, c, t.Owner)
	}
	t.Owner = owner
	t.Kind = "city"
	return g.Set(t)
}

// Neighbors 返回以 center 为中心的九宫格内、落在世界范围内的坐标，
// 包含 center 本身。边界上的中心点自然少于九个，这就是视野裁剪。
func (g *Grid) Neighbors(center Coord) ([]Coord, error) {
	if !g.InBounds(center) {
		return nil, fmt.Errorf("%w: center %s", ErrOutOfBounds, center)
	}
	out := make([]Coord, 0, 9)
	for dy := -1; dy <= 1; dy++ {
		for dx := -1; dx <= 1; dx++ {
			c := Coord{X: center.X + dx, Y: center.Y + dy}
			if g.InBounds(c) {
				out = append(out, c)
			}
		}
	}
	return out, nil
}

// Neighborhood 合并多个中心的九宫格并去重。联盟视野、多人协同侦查
// 都会出现相邻玩家看到同一块地的情况，去重必须在服务端完成。
func (g *Grid) Neighborhood(centers []Coord) ([]Coord, error) {
	if len(centers) == 0 {
		return nil, nil
	}
	seen := make(map[Coord]struct{}, len(centers)*9)
	for _, center := range centers {
		nb, err := g.Neighbors(center)
		if err != nil {
			return nil, err
		}
		for _, c := range nb {
			seen[c] = struct{}{}
		}
	}
	out := make([]Coord, 0, len(seen))
	for c := range seen {
		out = append(out, c)
	}
	sort.Slice(out, func(i, j int) bool {
		if out[i].Y != out[j].Y {
			return out[i].Y < out[j].Y
		}
		return out[i].X < out[j].X
	})
	return out, nil
}

// Snapshot 只导出已加载或已修改的地块，保证快照大小与活跃区域成正比。
type Snapshot struct {
	Width  int
	Height int
	Tiles  []Tile
}

func (g *Grid) Snapshot() Snapshot {
	tiles := make([]Tile, 0, len(g.tiles))
	for _, t := range g.tiles {
		tiles = append(tiles, t)
	}
	sort.Slice(tiles, func(i, j int) bool {
		if tiles[i].Coord.Y != tiles[j].Coord.Y {
			return tiles[i].Coord.Y < tiles[j].Coord.Y
		}
		return tiles[i].Coord.X < tiles[j].Coord.X
	})
	return Snapshot{Width: g.width, Height: g.height, Tiles: tiles}
}

// Restore 从快照恢复网格，并拒绝任何越界地块。
func Restore(s Snapshot) (*Grid, error) {
	g, err := NewGrid(s.Width, s.Height)
	if err != nil {
		return nil, err
	}
	for _, t := range s.Tiles {
		if err := g.Set(t); err != nil {
			return nil, fmt.Errorf("worldmap: restore: %w", err)
		}
	}
	return g, nil
}

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

ok  	gspractice/ch20/worldmap	0.249s