《MMO 服务器开发》3.3 分线、副本与主城/野外

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

import (
	"errors"
	"sync"
)

// LineID 是一条分线的 ID。
type LineID uint64

// SceneKind 决定「进入这张地图」怎么落地：共享分线，还是独立实例。
type SceneKind uint8

const (
	KindOpenWorld SceneKind = iota // 野外 / 主城：多人在同一条分线里共享
	KindDungeon                    // 副本：每次进入开一个独立实例
)

// WorldMap 是地图模板的元信息：类型 + 每条分线的人数上限。
type WorldMap struct {
	ID              uint32
	Kind            SceneKind
	CapacityPerLine int
}

// Line 是一条分线：与同地图其他分线共享同一份地图模板，只隔离玩家集合。
type Line struct {
	ID       LineID
	MapID    uint32
	players  map[uint64]struct{}
	capacity int
}

func (l *Line) PlayerCount() int { return len(l.players) }

// LineManager 负责野外/主城的分线分配：塞满一条就开下一条。
type LineManager struct {
	mu    sync.Mutex
	next  LineID
	lines map[LineID]*Line
	byMap map[uint32][]LineID
}

func NewLineManager() *LineManager {
	return &LineManager{
		lines: make(map[LineID]*Line),
		byMap: make(map[uint32][]LineID),
	}
}

// Assign 把玩家放进 mapID 的一条分线：优先第一条未满的，都满了就新开一条。
func (lm *LineManager) Assign(m *WorldMap, player uint64) LineID {
	lm.mu.Lock()
	defer lm.mu.Unlock()
	for _, id := range lm.byMap[m.ID] {
		l := lm.lines[id]
		if len(l.players) < l.capacity {
			l.players[player] = struct{}{}
			return id
		}
	}
	lm.next++
	l := &Line{
		ID:       lm.next,
		MapID:    m.ID,
		players:  make(map[uint64]struct{}),
		capacity: m.CapacityPerLine,
	}
	l.players[player] = struct{}{}
	lm.lines[l.ID] = l
	lm.byMap[m.ID] = append(lm.byMap[m.ID], l.ID)
	return l.ID
}

// Leave 把玩家移出一条分线；空分线保留，由运维侧按需合线。
func (lm *LineManager) Leave(id LineID, player uint64) bool {
	lm.mu.Lock()
	defer lm.mu.Unlock()
	l, ok := lm.lines[id]
	if !ok {
		return false
	}
	delete(l.players, player)
	return true
}

// LinesOf 返回某地图当前的分线数量，用于观测「是不是分得太碎」。
func (lm *LineManager) LinesOf(mapID uint32) int {
	lm.mu.Lock()
	defer lm.mu.Unlock()
	return len(lm.byMap[mapID])
}

// CountOn 返回某条分线当前人数。
func (lm *LineManager) CountOn(id LineID) int {
	lm.mu.Lock()
	defer lm.mu.Unlock()
	if l, ok := lm.lines[id]; ok {
		return len(l.players)
	}
	return 0
}

var ErrNoSuchMap = errors.New("scene: 未注册的地图")

// Router 把「进入一张地图」统一成两种落点：
//   - 野外 / 主城 -> 进一条共享分线（复用 LineManager）
//   - 副本       -> 开一个独立实例（复用 InstanceManager）
type Router struct {
	lines     *LineManager
	instances *InstanceManager
	maps      map[uint32]*MapData
}

func NewRouter(lines *LineManager, instances *InstanceManager) *Router {
	return &Router{lines: lines, instances: instances, maps: make(map[uint32]*MapData)}
}

// RegisterMap 注册地图模板，进入副本时要拿它开实例。
func (r *Router) RegisterMap(md *MapData) { r.maps[md.ID] = md }

// EnterWorld 返回落点：进分线则 line != 0，进副本则 inst != 0。
func (r *Router) EnterWorld(m *WorldMap, player uint64, tick int64) (LineID, InstanceID, error) {
	switch m.Kind {
	case KindOpenWorld:
		return r.lines.Assign(m, player), 0, nil
	case KindDungeon:
		md, ok := r.maps[m.ID]
		if !ok {
			return 0, 0, ErrNoSuchMap
		}
		inst := r.instances.Create(md, tick)
		if err := r.instances.Enter(inst.ID, player, tick); err != nil {
			return 0, 0, err
		}
		return 0, inst.ID, nil
	default:
		return 0, 0, ErrNoSuchMap
	}
}

// snippet: internal/scene/line_test.go（摘录）
func TestAssignFillsLinesThenOpensNew(t *testing.T) {
	lm := NewLineManager()
	city := &WorldMap{ID: 1, Kind: KindOpenWorld, CapacityPerLine: 2}

	// 5 个玩家、每条线容量 2 -> 应该开出 3 条线：2/2/1。
	lines := make([]LineID, 0, 5)
	for p := uint64(1); p <= 5; p++ {
		lines = append(lines, lm.Assign(city, p))
	}
	if got := lm.LinesOf(1); got != 3 {
		t.Fatalf("分线数 = %d，期望 3", got)
	}
	if lines[0] != lines[1] {
		t.Fatal("前两个玩家应落在同一条线")
	}
	if lines[2] != lines[3] {
		t.Fatal("第 3、4 个玩家应落在第二条线")
	}
	if lines[4] == lines[0] || lines[4] == lines[2] {
		t.Fatal("第 5 个玩家应落在第三条线")
	}
	if c := lm.CountOn(lines[0]); c != 2 {
		t.Fatalf("第一条线人数 = %d，期望 2", c)
	}
	// 走掉一个，空位应被后来者复用，不新开线。
	lm.Leave(lines[0], 1)
	again := lm.Assign(city, 6)
	if again != lines[0] {
		t.Fatalf("复用空位失败：得到线 %d，期望 %d", again, lines[0])
	}
	if lm.LinesOf(1) != 3 {
		t.Fatal("复用空位不应新开分线")
	}
}

func TestRouterOpenWorldVsDungeon(t *testing.T) {
	lm := NewLineManager()
	im := NewInstanceManager(10, 8)
	r := NewRouter(lm, im)

	md, _ := NewMapData(2, 16, 16)
	r.RegisterMap(md)

	field := &WorldMap{ID: 1, Kind: KindOpenWorld, CapacityPerLine: 10}
	dungeon := &WorldMap{ID: 2, Kind: KindDungeon}

	// 野外：两个玩家落同一条线。
	l1, i1, err := r.EnterWorld(field, 100, 0)
	if err != nil {
		t.Fatal(err)
	}
	l2, _, _ := r.EnterWorld(field, 101, 0)
	if i1 != 0 || l1 == 0 || l1 != l2 {
		t.Fatalf("野外落点异常: l1=%d l2=%d inst=%d", l1, l2, i1)
	}
	// 副本：两个玩家各拿一个独立实例。
	_, d1, _ := r.EnterWorld(dungeon, 100, 0)
	_, d2, _ := r.EnterWorld(dungeon, 101, 0)
	if d1 == 0 || d2 == 0 || d1 == d2 {
		t.Fatalf("副本应各自独立: d1=%d d2=%d", d1, d2)
	}
	if im.LiveCount() != 2 {
		t.Fatalf("副本实例数 = %d，期望 2", im.LiveCount())
	}
	// 未注册地图的副本进入要报错，而不是 panic。
	bad := &WorldMap{ID: 99, Kind: KindDungeon}
	if _, _, err := r.EnterWorld(bad, 1, 0); err != ErrNoSuchMap {
		t.Fatalf("未注册地图 = %v，期望 ErrNoSuchMap", err)
	}
}

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

$ go test ./internal/scene/
ok  	aegis/internal/scene	0.4s   （10 个 test 全绿）

$ go test -run TestAssignFillsLinesThenOpensNew -v ./internal/scene/
=== RUN   TestAssignFillsLinesThenOpensNew
--- PASS: TestAssignFillsLinesThenOpensNew (0.00s)