《MMO 服务器开发》3.1 地图数据结构与逻辑坐标

GridSize = 8.0
世界坐标 X:  0.0      8.0      16.0     24.0
            |         |         |        |
格号 cx:     [   0    ][   1    ][   2   ]
格中心 X:     4.0      12.0      20.0

WorldToGrid(Vec2{20, 20})  ->  cx=20/8=2.5 -> Floor -> 2
GridCenter(2, 2)           ->  (2+0.5)*8 = 20.0  （与输入一致）

// file: internal/scene/map.go
// tier: L1
// verify: go test ./internal/scene/
package scene

import (
	"errors"
	"fmt"
	"math"
)

// GridSize 是逻辑坐标系里一个格子的边长（世界单位）。
// 服务器的一切阻挡、AOI、寻路都以它为单位，与客户端像素无关。
const GridSize = 8.0

// Vec2 是服务器的逻辑坐标：float64 连续量，与客户端像素坐标解耦。
// 客户端按自己的分辨率渲染，服务器只认这一套坐标。
type Vec2 struct {
	X, Y float64
}

func (p Vec2) Add(o Vec2) Vec2 { return Vec2{X: p.X + o.X, Y: p.Y + o.Y} }
func (p Vec2) Sub(o Vec2) Vec2 { return Vec2{X: p.X - o.X, Y: p.Y - o.Y} }

// Dist2 返回平方距离：比较远近时不必开方，省一次 sqrt。
func (p Vec2) Dist2(o Vec2) float64 {
	dx, dy := p.X-o.X, p.Y-o.Y
	return dx*dx + dy*dy
}

// ErrOutOfMap 表示坐标或格号落在地图之外。
var ErrOutOfMap = errors.New("scene: 坐标超出地图范围")

// MapData 是静态地图：一张 Width×Height 的格网，加每格是否阻挡。
// 它是只读模板，被所有实例共享；运行时状态不写回这里。
type MapData struct {
	ID      uint32
	Width   int    // 列数（格）
	Height  int    // 行数（格）
	blocked []bool // 长度 Width*Height，true = 不可走
}

// NewMapData 分配一张空地图（全部可走）。
func NewMapData(id uint32, w, h int) (*MapData, error) {
	if w <= 0 || h <= 0 {
		return nil, fmt.Errorf("scene: 非法地图尺寸 %dx%d", w, h)
	}
	return &MapData{ID: id, Width: w, Height: h, blocked: make([]bool, w*h)}, nil
}

func (m *MapData) idx(cx, cy int) int { return cy*m.Width + cx }

func (m *MapData) InBounds(cx, cy int) bool {
	return cx >= 0 && cx < m.Width && cy >= 0 && cy < m.Height
}

func (m *MapData) SetBlocked(cx, cy int, b bool) error {
	if !m.InBounds(cx, cy) {
		return ErrOutOfMap
	}
	m.blocked[m.idx(cx, cy)] = b
	return nil
}

// IsBlocked：界外一律视为阻挡，这样移动校验不必再单独判越界。
func (m *MapData) IsBlocked(cx, cy int) bool {
	if !m.InBounds(cx, cy) {
		return true
	}
	return m.blocked[m.idx(cx, cy)]
}

// WorldToGrid 把逻辑坐标落到格号。用 Floor 而非整除，负坐标才不会截断到 0。
func WorldToGrid(p Vec2) (int, int) {
	return int(math.Floor(p.X / GridSize)), int(math.Floor(p.Y / GridSize))
}

// GridCenter 返回某格中心的世界坐标，用于把实体吸附到格心。
func GridCenter(cx, cy int) Vec2 {
	return Vec2{X: (float64(cx) + 0.5) * GridSize, Y: (float64(cy) + 0.5) * GridSize}
}

// WalkableAt 判断一个逻辑坐标能否站立。
func (m *MapData) WalkableAt(p Vec2) bool {
	cx, cy := WorldToGrid(p)
	return !m.IsBlocked(cx, cy)
}

// ClampToBounds 把坐标夹到地图内，防止越界坐标把实体推出世界。
func (m *MapData) ClampToBounds(p Vec2) Vec2 {
	maxX := float64(m.Width) * GridSize
	maxY := float64(m.Height) * GridSize
	p.X = math.Max(0, math.Min(p.X, math.Nextafter(maxX, 0)))
	p.Y = math.Max(0, math.Min(p.Y, math.Nextafter(maxY, 0)))
	return p
}

// snippet: internal/scene/map_test.go（摘录）
func TestWorldToGridRoundsDown(t *testing.T) {
	cases := []struct {
		p  Vec2
		cx int
		cy int
	}{
		{Vec2{0, 0}, 0, 0},
		{Vec2{7.999, 7.999}, 0, 0},
		{Vec2{8.0, 8.0}, 1, 1},
		{Vec2{15.9, 16.1}, 1, 2},
		{Vec2{-0.1, -8.1}, -1, -2}, // 负坐标必须向下取整到 -1 / -2
	}
	for _, c := range cases {
		cx, cy := WorldToGrid(c.p)
		if cx != c.cx || cy != c.cy {
			t.Errorf("WorldToGrid(%v) = (%d,%d)，期望 (%d,%d)", c.p, cx, cy, c.cx, c.cy)
		}
	}
}

func TestClampToBounds(t *testing.T) {
	m, _ := NewMapData(1, 4, 4)
	max := float64(4) * GridSize // 32
	got := m.ClampToBounds(Vec2{X: -5, Y: 999})
	if got.X != 0 {
		t.Errorf("X 应夹到 0，实得 %v", got.X)
	}
	if !(got.Y < max) {
		t.Errorf("Y 应夹到 < %v，实得 %v", max, got.Y)
	}
	if cx, cy := WorldToGrid(got); cx != 0 || cy != 3 {
		t.Errorf("夹取后应落在 (0,3)，实得 (%d,%d)", cx, cy)
	}
}

$ go vet ./...
（无输出，通过）

$ go test ./internal/scene/
ok  	aegis/internal/scene	0.4s