《游戏服务端编程实践》7.1.1 世界分区与逻辑坐标

// file: ch07/world/coord.go
// tier: L1
// verify: go test ./ch07/world/

package world

import "fmt"

// ZoneSize 是正方形分区的边长，单位与逻辑坐标一致：1 单位 = 1 厘米。
const ZoneSize int64 = 100 * 100

// WorldCoord 是服务器内部的逻辑坐标，原点是世界的左下角，允许为负。
type WorldCoord struct {
	X int64
	Y int64
}

func (p WorldCoord) Add(dx, dy int64) WorldCoord { return WorldCoord{X: p.X + dx, Y: p.Y + dy} }

// ZoneID 是矩形网格的分区编号。分区键必须是整数对，绝不能用浮点数。
type ZoneID struct {
	X int64
	Y int64
}

func (z ZoneID) String() string { return fmt.Sprintf("zone(%d,%d)", z.X, z.Y) }

// Key 是分区在哈希表中的稳定键，格式与日志一致，便于排查。
func (z ZoneID) Key() string { return fmt.Sprintf("%d:%d", z.X, z.Y) }

// FloorDiv 做向下取整除法。Go 的 / 向零截断，负数坐标会因此落错分区。
func FloorDiv(v, size int64) int64 {
	if size <= 0 {
		panic("world: non-positive divisor")
	}
	q := v / size
	if v%size != 0 && v < 0 {
		q--
	}
	return q
}

// ZoneOf 把逻辑坐标换算成分区编号。区间按左闭右开处理：
// 坐标 10000 属于 X=1 的分区，9999 仍属于 X=0。
func ZoneOf(p WorldCoord) ZoneID {
	return ZoneID{X: FloorDiv(p.X, ZoneSize), Y: FloorDiv(p.Y, ZoneSize)}
}

// ZoneOrigin 返回分区左下角的逻辑坐标。
func ZoneOrigin(z ZoneID) WorldCoord {
	return WorldCoord{X: z.X * ZoneSize, Y: z.Y * ZoneSize}
}

// Local 返回点相对所属分区原点的偏移，范围是 [0, ZoneSize)。
func Local(p WorldCoord) WorldCoord {
	z := ZoneOf(p)
	return WorldCoord{X: p.X - z.X*ZoneSize, Y: p.Y - z.Y*ZoneSize}
}

// Neighbors 返回八邻接分区（不含自身），顺序固定，便于测试与广播去重。
func (z ZoneID) Neighbors() [8]ZoneID {
	return [8]ZoneID{
		{X: z.X - 1, Y: z.Y - 1},
		{X: z.X, Y: z.Y - 1},
		{X: z.X + 1, Y: z.Y - 1},
		{X: z.X - 1, Y: z.Y},
		{X: z.X + 1, Y: z.Y},
		{X: z.X - 1, Y: z.Y + 1},
		{X: z.X, Y: z.Y + 1},
		{X: z.X + 1, Y: z.Y + 1},
	}
}

// CrossZone 描述一次跨区迁移：实体被从 From 移交给 To。
type CrossZone struct {
	EntityID uint64
	From     ZoneID
	To       ZoneID
}

// PlanCross 在坐标变化后判断是否需要跨区；仍在同一分区时返回 nil。
func PlanCross(entityID uint64, from, to WorldCoord) *CrossZone {
	a, b := ZoneOf(from), ZoneOf(to)
	if a == b {
		return nil
	}
	return &CrossZone{EntityID: entityID, From: a, To: b}
}

// ValidCross 限制一次迁移最多跨一个分区。跳跃式坐标应拆成多步，
// 或按瞬移/作弊处理，不能直接在新分区里凭空出现。
func (c CrossZone) ValidCross() bool {
	dx := c.To.X - c.From.X
	dy := c.To.Y - c.From.Y
	if dx < -1 || dx > 1 || dy < -1 || dy > 1 {
		return false
	}
	return dx != 0 || dy != 0
}

// file: ch07/world/coord_test.go
// tier: L1
// verify: go test ./ch07/world/

package world

import "testing"

func TestZoneOfBoundaries(t *testing.T) {
	cases := []struct {
		p    WorldCoord
		want ZoneID
	}{
		{WorldCoord{X: 0, Y: 0}, ZoneID{X: 0, Y: 0}},
		{WorldCoord{X: ZoneSize - 1, Y: ZoneSize - 1}, ZoneID{X: 0, Y: 0}},
		{WorldCoord{X: ZoneSize, Y: ZoneSize}, ZoneID{X: 1, Y: 1}},
		{WorldCoord{X: -1, Y: -1}, ZoneID{X: -1, Y: -1}},
		{WorldCoord{X: -ZoneSize, Y: -ZoneSize}, ZoneID{X: -1, Y: -1}},
		{WorldCoord{X: -ZoneSize - 1, Y: 0}, ZoneID{X: -2, Y: 0}},
		{WorldCoord{X: ZoneSize * 3, Y: -ZoneSize * 2}, ZoneID{X: 3, Y: -2}},
	}
	for _, c := range cases {
		if got := ZoneOf(c.p); got != c.want {
			t.Fatalf("ZoneOf(%+v) = %v, want %v", c.p, got, c.want)
		}
	}
}

func TestZoneBoundaryIsHalfOpen(t *testing.T) {
	if got := ZoneOf(WorldCoord{X: ZoneSize - 1, Y: 0}).X; got != 0 {
		t.Fatalf("left of boundary = %d, want 0", got)
	}
	if got := ZoneOf(WorldCoord{X: ZoneSize, Y: 0}).X; got != 1 {
		t.Fatalf("on boundary = %d, want 1", got)
	}
	if got := Local(WorldCoord{X: -1, Y: -1}); got != (WorldCoord{X: ZoneSize - 1, Y: ZoneSize - 1}) {
		t.Fatalf("Local(-1,-1) = %+v", got)
	}
}

func TestZoneOriginRoundTrip(t *testing.T) {
	points := []WorldCoord{
		{X: 0, Y: 0},
		{X: 1, Y: 1},
		{X: ZoneSize - 1, Y: -1},
		{X: -ZoneSize - 1, Y: ZoneSize*2 + 7},
		{X: 123456789, Y: -987654321},
	}
	for _, p := range points {
		z := ZoneOf(p)
		back := ZoneOrigin(z).Add(Local(p).X, Local(p).Y)
		if back != p {
			t.Fatalf("round trip %+v -> %v -> %+v", p, z, back)
		}
	}
}

func TestNeighborsAreEightAndExcludeSelf(t *testing.T) {
	z := ZoneID{X: 2, Y: -3}
	got := z.Neighbors()
	if len(got) != 8 {
		t.Fatalf("len(Neighbors) = %d, want 8", len(got))
	}
	seen := make(map[ZoneID]bool, len(got))
	for _, n := range got {
		if n == z {
			t.Fatalf("Neighbors contains self: %v", z)
		}
		if seen[n] {
			t.Fatalf("duplicate neighbor: %v", n)
		}
		seen[n] = true
	}
	for dx := int64(-1); dx <= 1; dx++ {
		for dy := int64(-1); dy <= 1; dy++ {
			if dx == 0 && dy == 0 {
				continue
			}
			want := ZoneID{X: z.X + dx, Y: z.Y + dy}
			if !seen[want] {
				t.Fatalf("missing neighbor %v", want)
			}
		}
	}
}

func TestPlanCross(t *testing.T) {
	if c := PlanCross(7, WorldCoord{X: 100, Y: 100}, WorldCoord{X: 200, Y: 200}); c != nil {
		t.Fatalf("same zone returned %+v", c)
	}
	c := PlanCross(7, WorldCoord{X: ZoneSize - 1, Y: 100}, WorldCoord{X: ZoneSize + 1, Y: 100})
	if c == nil || c.From != (ZoneID{X: 0, Y: 0}) || c.To != (ZoneID{X: 1, Y: 0}) {
		t.Fatalf("cross-zone = %+v", c)
	}
	if !c.ValidCross() {
		t.Fatal("adjacent zone should be valid")
	}
	jump := CrossZone{EntityID: 7, From: ZoneID{X: 0, Y: 0}, To: ZoneID{X: 3, Y: 0}}
	if jump.ValidCross() {
		t.Fatal("three-zone jump should be rejected")
	}
	same := CrossZone{EntityID: 7, From: ZoneID{X: 0, Y: 0}, To: ZoneID{X: 0, Y: 0}}
	if same.ValidCross() {
		t.Fatal("same zone should not be a crossing")
	}
}

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

ok  	gspractice/ch07/world	0.266s