从 Spring Boot 到 Go
亲手写一个多人 HD2D 服务端

# 方式一：winget
winget install --id GoLang.Go

# 方式二：从 https://go.dev/dl/ 下载 MSI 安装包

# 验证（应 ≥ 1.22）
go version
go env GOPATH GOMODCACHE

module hd2d

go 1.22

package main

import "fmt"

func main() {
	fmt.Println("hd2d server: booting")
}

go run ./cmd/hello          # 编译到临时目录并执行
go build -o bin/hello ./cmd/hello   # 产出可执行文件
go test ./...               # 跑全部测试（此刻还没有）

# 交叉编译一个 Linux 版本（部署章节会用到）
$env:GOOS="linux"; $env:GOARCH="amd64"; go build -o bin/hello-linux ./cmd/hello

package game

import "fmt"

type EntityID string

type Vec2 struct {
	X, Y float64
}

type MoveComp struct {
	Speed float64 // tile / 秒
}

type HealthComp struct {
	HP, MaxHP int
}

type CombatComp struct {
	ReadyAt map[string]uint64 // skillID → 可再次释放的 tick
}

type Entity struct {
	ID     EntityID
	Kind   string // "player" | "npc"
	Pos    Vec2
	Z      int8
	Dir    int
	Move   MoveComp
	Health HealthComp
	Combat CombatComp
}

func (e *Entity) Alive() bool { return e.Health.HP > 0 }

func (e *Entity) Damage(n int) error {
	if n <= 0 {
		return fmt.Errorf("damage must be positive, got %d", n)
	}
	if !e.Alive() {
		return fmt.Errorf("entity %s is already down", e.ID)
	}
	e.Health.HP -= n
	if e.Health.HP < 0 {
		e.Health.HP = 0
	}
	return nil
}

package game

import "context"

type Save struct {
	Token   string
	MapID   string
	X, Y    float64
	Z       int8
	HP      int
	Updated int64
}

// SaveStore 由 game 包定义；persist 包实现它。
// 这样 game 不依赖数据库，测试可以塞一个内存假实现。
type SaveStore interface {
	Load(ctx context.Context, token string) (Save, bool, error)
	Upsert(ctx context.Context, s Save) error
}

package learn

// 错误：append 后的新切片没有返回给调用方
func AddBroken(xs []int) { xs = append(xs, 99) }

// 正确：返回新切片
func AddOK(xs []int) []int { return append(xs, 99) }

// 错误：nil map 写入会 panic
func MeterBroken() {
	var cooldown map[string]uint64
	cooldown["slash"] = 10 // panic: assignment to entry in nil map
}

// 正确：显式初始化
func MeterOK() map[string]uint64 {
	return map[string]uint64{"slash": 10}
}

// defer 在函数返回前执行，常用于解锁、关文件、计耗时。
// 注意：defer 的参数在注册时就求值。
func SafeRun(fn func()) (err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("recovered from panic: %v", r)
		}
	}()
	fn()
	return nil
}

package learn

import (
	"context"
	"sync"
	"time"
)

// FanOut 启动 workers 个协程消费 jobs，结果写入返回的 channel。
// 两个关键点：所有协程都能被 ctx 取消；输出 channel 由唯一的收尾协程关闭。
func FanOut(ctx context.Context, jobs <-chan int, workers int) <-chan int {
	out := make(chan int)
	var wg sync.WaitGroup

	for i := 0; i < workers; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for {
				select {
				case <-ctx.Done():
					return
				case j, ok := <-jobs:
					if !ok {
						return
					}
					select {
					case out <- j * j:
					case <-ctx.Done():
						return
					}
				}
			}
		}()
	}

	go func() {
		wg.Wait()
		close(out) // 只有发送方能关；这里只有一个收尾协程，安全
	}()
	return out
}

func WaitMsg(ctx context.Context, ch <-chan string) (string, error) {
	select {
	case s, ok := <-ch:
		if !ok {
			return "", nil
		}
		return s, nil
	case <-ctx.Done():
		return "", ctx.Err()
	}
}

// 超时只是带 deadline 的 context
func WaitWithTimeout(ch <-chan string, d time.Duration) (string, error) {
	ctx, cancel := context.WithTimeout(context.Background(), d)
	defer cancel()
	return WaitMsg(ctx, ch)
}

type Counter struct {
	mu sync.Mutex
	n  int
}

func (c *Counter) Inc() int {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.n++
	return c.n
}

package config

import "os"

type Config struct {
	Addr   string
	DBPath string
}

func Load() Config {
	return Config{
		Addr:   getenv("HD2D_ADDR", ":8080"),
		DBPath: getenv("HD2D_DB", "hd2d.db"),
	}
}

func getenv(key, def string) string {
	if v := os.Getenv(key); v != "" {
		return v
	}
	return def
}

package main

import (
	"context"
	"encoding/json"
	"errors"
	"log/slog"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"hd2d/internal/config"
)

type errorBody struct {
	Code string `json:"code"`
	Msg  string `json:"msg"`
}

func main() {
	cfg := config.Load()
	log := slog.New(slog.NewJSONHandler(os.Stdout, nil))

	mux := http.NewServeMux()
	mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) {
		writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
	})
	mux.HandleFunc("POST /api/echo", func(w http.ResponseWriter, r *http.Request) {
		var in struct {
			Name string `json:"name"`
		}
		body := http.MaxBytesReader(w, r.Body, 4096)
		if err := json.NewDecoder(body).Decode(&in); err != nil {
			writeJSON(w, http.StatusBadRequest, errorBody{Code: "bad_json", Msg: err.Error()})
			return
		}
		writeJSON(w, http.StatusOK, map[string]string{"hello": in.Name})
	})

	srv := &http.Server{
		Addr:              cfg.Addr,
		Handler:           withLogging(log, mux),
		ReadHeaderTimeout: 5 * time.Second,
	}

	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer stop()

	go func() {
		log.Info("http listening", "addr", srv.Addr)
		if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
			log.Error("listen failed", "err", err)
			stop()
		}
	}()

	<-ctx.Done()
	shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	if err := srv.Shutdown(shutdownCtx); err != nil {
		log.Error("shutdown", "err", err)
	}
	log.Info("bye")
}

func writeJSON(w http.ResponseWriter, status int, v any) {
	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	w.WriteHeader(status)
	_ = json.NewEncoder(w).Encode(v)
}

func withLogging(log *slog.Logger, next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		start := time.Now()
		next.ServeHTTP(w, r)
		log.Info("http", "method", r.Method, "path", r.URL.Path,
			"cost_ms", time.Since(start).Milliseconds())
	})
}

package protocol

import (
	"encoding/json"
	"errors"
)

type ClientMsg struct {
	T      string  `json:"t"`
	Seq    int64   `json:"seq,omitempty"`
	DT     int     `json:"dt,omitempty"`
	MX     float64 `json:"mx,omitempty"`
	MY     float64 `json:"my,omitempty"`
	Cast   string  `json:"cast,omitempty"`
	Target string  `json:"target,omitempty"`
}

type EntityDTO struct {
	ID   string  `json:"id"`
	Kind string  `json:"kind"`
	X    float64 `json:"x"`
	Y    float64 `json:"y"`
	Z    int     `json:"z"`
	HP   int     `json:"hp"`
	Dir  int     `json:"dir"`
}

type EventDTO struct {
	Type   string  `json:"type"`
	Src    string  `json:"src,omitempty"`
	Dst    string  `json:"dst,omitempty"`
	Amount int     `json:"amount,omitempty"`
	X      float64 `json:"x,omitempty"`
	Y      float64 `json:"y,omitempty"`
}

type ServerMsg struct {
	T        string      `json:"t"`
	PID      string      `json:"pid,omitempty"`
	Token    string      `json:"token,omitempty"`
	TickRate int         `json:"tickRate,omitempty"`
	Tick     uint64      `json:"tick,omitempty"`
	Entities []EntityDTO `json:"entities,omitempty"`
	Events   []EventDTO  `json:"events,omitempty"`
	Code     string      `json:"code,omitempty"`
	Msg      string      `json:"msg,omitempty"`
}

var ErrEmptyType = errors.New("empty message type")

func DecodeClient(b []byte) (ClientMsg, error) {
	var m ClientMsg
	if err := json.Unmarshal(b, &m); err != nil {
		return ClientMsg{}, err
	}
	if m.T == "" {
		return ClientMsg{}, ErrEmptyType
	}
	return m, nil
}

func Encode(v any) ([]byte, error) { return json.Marshal(v) }

package netws

import (
	"sync"
	"time"

	"github.com/gorilla/websocket"

	"hd2d/internal/protocol"
)

const (
	writeWait  = 10 * time.Second
	pongWait   = 60 * time.Second
	pingPeriod = 54 * time.Second
	readLimit  = 4096
)

type Client struct {
	conn      *websocket.Conn
	send      chan []byte
	id        string
	closed    chan struct{}
	closeOnce sync.Once
}

func NewClient(conn *websocket.Conn, id string) *Client {
	return &Client{
		conn:   conn,
		send:   make(chan []byte, 64), // 缓冲 64 帧，够 3 秒左右
		id:     id,
		closed: make(chan struct{}),
	}
}

func (c *Client) ID() string { return c.id }

// SendMessage 非阻塞：满了返回 false，调用方据此判定慢客户端。
func (c *Client) SendMessage(b []byte) bool {
	select {
	case c.send <- b:
		return true
	case <-c.closed:
		return false
	default:
		return false
	}
}

func (c *Client) Close() {
	c.closeOnce.Do(func() {
		close(c.closed)
		_ = c.conn.Close()
	})
}

// ReadPump 是唯一的读者；onMsg 只做解析后的分发，不能在这里写连接。
func (c *Client) ReadPump(onMsg func(protocol.ClientMsg) error) {
	defer c.Close()

	c.conn.SetReadLimit(readLimit)
	_ = c.conn.SetReadDeadline(time.Now().Add(pongWait))
	c.conn.SetPongHandler(func(string) error {
		return c.conn.SetReadDeadline(time.Now().Add(pongWait))
	})

	for {
		_, data, err := c.conn.ReadMessage()
		if err != nil {
			return // 断开、超时、协议错误都会走到这里
		}
		msg, err := protocol.DecodeClient(data)
		if err != nil {
			out, _ := protocol.Encode(protocol.ServerMsg{T: "error", Code: "bad_frame", Msg: err.Error()})
			c.SendMessage(out)
			continue
		}
		if err := onMsg(msg); err != nil {
			return
		}
	}
}

// WritePump 是唯一的写者；业务永远不直接写连接。
func (c *Client) WritePump() {
	ticker := time.NewTicker(pingPeriod)
	defer func() {
		ticker.Stop()
		c.Close()
	}()

	for {
		select {
		case msg, ok := <-c.send:
			_ = c.conn.SetWriteDeadline(time.Now().Add(writeWait))
			if !ok {
				return
			}
			if err := c.conn.WriteMessage(websocket.TextMessage, msg); err != nil {
				return
			}
		case <-ticker.C:
			if err := c.conn.WriteControl(websocket.PingMessage, nil,
				time.Now().Add(writeWait)); err != nil {
				return
			}
		case <-c.closed:
			return
		}
	}
}

package netws

import (
	"crypto/rand"
	"encoding/hex"
	"log/slog"
	"net/http"

	"github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
	ReadBufferSize:  1024,
	WriteBufferSize: 1024,
	CheckOrigin: func(r *http.Request) bool {
		// 教学环境放开；生产必须按 Origin 白名单校验
		return true
	},
}

func ServeWS(w http.ResponseWriter, r *http.Request, log *slog.Logger, onConn func(*Client)) {
	conn, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		log.Warn("ws upgrade failed", "err", err)
		return
	}
	c := NewClient(conn, newID())
	onConn(c)
}

func newID() string {
	b := make([]byte, 16)
	if _, err := rand.Read(b); err != nil {
		return "anon"
	}
	return hex.EncodeToString(b)
}

package game

import (
	"context"
	"log/slog"
	"time"

	"hd2d/internal/protocol"
)

const (
	TickRate      = 20
	TickInterval  = time.Second / TickRate
	TickBudget    = 5 * time.Millisecond
	SnapshotEvery = 2 // 每 2 tick 发一次快照 = 10Hz
)

// Session 由网络层实现；game 只依赖这个最小接口，避免反向依赖 netws。
type Session interface {
	SendMessage([]byte) bool
	Close()
}

type Command struct {
	Player EntityID
	Msg    protocol.ClientMsg
}

type joinReq struct {
	Token string
	Sess  Session
	Done  chan joinResult
}

type joinResult struct {
	ID  EntityID
	Err error
}

type leaveReq struct{ ID EntityID }

type Room struct {
	ID    string
	Map   *TileMap
	Store SaveStore
	Log   *slog.Logger

	tick    uint64
	players map[EntityID]*Player
	npcs    map[EntityID]*NPC
	tokens  map[string]*Player
	events  []Event
	dirty   map[EntityID]bool

	cmds  chan Command
	join  chan joinReq
	leave chan leaveReq
}

func NewRoom(id string, tm *TileMap, store SaveStore, log *slog.Logger) *Room {
	return &Room{
		ID:      id,
		Map:     tm,
		Store:   store,
		Log:     log,
		players: map[EntityID]*Player{},
		npcs:    map[EntityID]*NPC{},
		tokens:  map[string]*Player{},
		dirty:   map[EntityID]bool{},
		cmds:    make(chan Command, 256),
		join:    make(chan joinReq, 16),
		leave:   make(chan leaveReq, 16),
	}
}

// Run 是房间唯一的写者。除了这个 goroutine，谁都不准碰 players。
func (r *Room) Run(ctx context.Context) {
	t := time.NewTicker(TickInterval)
	defer t.Stop()

	for {
		select {
		case <-ctx.Done():
			// 用全新的超时 context 落盘；原 ctx 已取消，不能再用。
			saveCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
			r.persistDirty(saveCtx)
			cancel()
			return
		case <-t.C:
			start := time.Now()
			r.step()
			if cost := time.Since(start); cost > TickBudget {
				r.Log.Warn("tick over budget", "room", r.ID,
					"cost_ms", cost.Milliseconds(), "tick", r.tick)
			}
		}
	}
}

func (r *Room) step() {
	r.drain()
	r.tick++
	for _, p := range r.players {
		r.stepPlayer(p)
	}
	for _, n := range r.npcs {
		r.stepNPC(n)
	}
	if r.tick%SnapshotEvery == 0 {
		r.broadcast()
		r.events = r.events[:0]
	}
}

// drain 一次性取空入口队列；channel 关闭是 tick 协程的私事。
func (r *Room) drain() {
	for {
		select {
		case c := <-r.cmds:
			r.applyCommand(c)
		case req := <-r.join:
			r.addPlayer(req)
		case req := <-r.leave:
			r.markOffline(req.ID)
		default:
			return
		}
	}
}

// Submit 由读泵调用；队列满直接返回 false，由调用方决定踢人还是丢弃。
func (r *Room) Submit(id EntityID, m protocol.ClientMsg) bool {
	select {
	case r.cmds <- Command{Player: id, Msg: m}:
		return true
	default:
		return false
	}
}

// Join 阻塞到 tick 协程处理完（最多一个 tick，约 50ms）。
func (r *Room) Join(ctx context.Context, token string, sess Session) (EntityID, error) {
	done := make(chan joinResult, 1)
	req := joinReq{Token: token, Sess: sess, Done: done}
	select {
	case r.join <- req:
	case <-ctx.Done():
		return "", ctx.Err()
	}
	select {
	case out := <-done:
		return out.ID, out.Err
	case <-ctx.Done():
		return "", ctx.Err()
	}
}

func (r *Room) Leave(id EntityID) {
	select {
	case r.leave <- leaveReq{ID: id}:
	default: // 队列满时，连接关闭本身已会让读泵退出
	}
}

func (r *Room) applyCommand(c Command) {
	p := r.players[c.Player]
	if p == nil || !p.Online() {
		return
	}
	switch c.Msg.T {
	case "input":
		if c.Msg.Seq <= p.LastSeq {
			return // 重放或乱序，直接丢
		}
		p.LastSeq = c.Msg.Seq
		dt := c.Msg.DT
		if dt < 0 {
			dt = 0
		}
		if dt > 100 {
			dt = 100 // 上限 100ms，防瞬移
		}
		r.move(p, c.Msg.MX, c.Msg.MY, float64(dt))
	case "cast":
		r.cast(p, c.Msg.Cast, EntityID(c.Msg.Target))
	}
}

package game

import (
	"context"
	"log/slog"
	"sync"
)

type World struct {
	mu    sync.RWMutex // 只保护 rooms 这张表，不保护世界状态
	rooms map[string]*Room
	Store SaveStore
	Log   *slog.Logger
}

func NewWorld(store SaveStore, log *slog.Logger) *World {
	return &World{rooms: map[string]*Room{}, Store: store, Log: log}
}

func (w *World) AddRoom(r *Room) {
	w.mu.Lock()
	defer w.mu.Unlock()
	w.rooms[r.ID] = r
}

func (w *World) Room(id string) (*Room, bool) {
	w.mu.RLock()
	defer w.mu.RUnlock()
	r, ok := w.rooms[id]
	return r, ok
}

func (w *World) Run(ctx context.Context) {
	w.mu.RLock()
	rooms := make([]*Room, 0, len(w.rooms))
	for _, r := range w.rooms {
		rooms = append(rooms, r)
	}
	w.mu.RUnlock()

	var wg sync.WaitGroup
	for _, r := range rooms {
		wg.Add(1)
		go func(r *Room) {
			defer wg.Done()
			r.Run(ctx)
		}(r)
	}
	<-ctx.Done()
	wg.Wait()
}

type Point struct{ X, Y int }

type Player struct {
	*Entity
	Token     string
	Session   Session
	LastSeq   int64
	OfflineAt time.Time
}

func (p *Player) Online() bool { return p.Session != nil && p.OfflineAt.IsZero() }

type NPC struct {
	*Entity
	Path []Point
	Wait int
}

type Event struct {
	Type   string
	Src    EntityID
	Dst    EntityID
	Amount int
}

// 以下方法在第 06–08 章逐个替换成真实实现；本章先留空，
// 保证骨架能编译、两个客户端能连上、能看到 welcome。
func (r *Room) move(p *Player, mx, my float64, dtMS float64)    {}
func (r *Room) stepPlayer(p *Player)                            {}
func (r *Room) stepNPC(n *NPC)                                  {}
func (r *Room) cast(p *Player, skillID string, target EntityID) {}
func (r *Room) markOffline(id EntityID)                         {}
func (r *Room) persistDirty(ctx context.Context)                {}
func (r *Room) broadcast()                                      {}

// shortID 只取 token 前 8 位做可读 ID；客户端传来的 token 长度不可信。
func shortID(token string) string {
	if len(token) > 8 {
		return token[:8]
	}
	return token
}

// randomToken 首次连接时由服务端发放，客户端保存后用于重连。
func randomToken() string {
	b := make([]byte, 16)
	if _, err := rand.Read(b); err != nil {
		return "fallback-token"
	}
	return hex.EncodeToString(b)
}

func (r *Room) addPlayer(req joinReq) {
	token := req.Token
	if token == "" {
		token = randomToken()
	}
	sp := r.Map.Spawn()
	p := &Player{
		Entity: &Entity{
			ID:   EntityID("p-" + shortID(token)),
			Kind: "player",
			Pos:  Vec2{X: sp.X, Y: sp.Y},
			Z:    r.Map.HeightAt(int(sp.X), int(sp.Y)),
			Move:   MoveComp{Speed: 4.0},
			Health: HealthComp{HP: 100, MaxHP: 100},
			Combat: CombatComp{ReadyAt: map[string]uint64{}},
		},
		Token:   token,
		Session: req.Sess,
	}
	r.players[p.ID] = p
	r.tokens[token] = p
	r.dirty[p.ID] = true

	// welcome 必须由 tick 协程发（这里就是），保证与实体状态同一时序。
	out, _ := protocol.Encode(protocol.ServerMsg{
		T: "welcome", PID: string(p.ID), Token: token, TickRate: TickRate,
	})
	req.Sess.SendMessage(out)
	req.Done <- joinResult{ID: p.ID}
}

package main

import (
	"encoding/json"
	"os"
	"strings"
)

type mapFile struct {
	W      int      `json:"w"`
	H      int      `json:"h"`
	Ground []string `json:"ground"`
	Block  []string `json:"block"`
	Height []string `json:"height"`
}

func main() {
	const w, h = 64, 48
	m := mapFile{W: w, H: h}

	for y := 0; y < h; y++ {
		var g, b, z strings.Builder
		for x := 0; x < w; x++ {
			// 地面花纹：4×4 棋盘交替草地 / 泥地
			if (x/4+y/4)%2 == 0 {
				g.WriteByte('g')
			} else {
				g.WriteByte('d')
			}

			// 碰撞：四周围墙 + 两根柱子 + 一段横墙
			blocked := x == 0 || y == 0 || x == w-1 || y == h-1
			if (x >= 20 && x <= 21 && y >= 8 && y <= 20) ||
				(y >= 30 && y <= 31 && x >= 10 && x <= 30) {
				blocked = true
			}
			// 出生点 7×7 保持空旷
			if x >= w/2-3 && x <= w/2+3 && y >= h/2-3 && y <= h/2+3 {
				blocked = false
			}
			if blocked {
				b.WriteByte('#')
			} else {
				b.WriteByte('.')
			}

			// 高度：右下角一级台地，台地中央再高一层
			ht := byte('0')
			if x >= 44 && x <= 52 && y >= 28 && y <= 34 {
				ht = '1'
			}
			if x >= 47 && x <= 49 && y >= 30 && y <= 32 {
				ht = '2'
			}
			z.WriteByte(ht)
		}
		m.Ground = append(m.Ground, g.String())
		m.Block = append(m.Block, b.String())
		m.Height = append(m.Height, z.String())
	}

	// go run ./cmd/mapgen  → 生成 testdata/maps/lobby.json
	if err := os.MkdirAll("testdata/maps", 0o755); err != nil {
		panic(err)
	}
	out, err := json.MarshalIndent(m, "", "  ")
	if err != nil {
		panic(err)
	}
	if err := os.WriteFile("testdata/maps/lobby.json", out, 0o644); err != nil {
		panic(err)
	}
}

package game

import (
	"encoding/json"
	"fmt"
	"math"
	"os"
)

type TileMap struct {
	W, H   int
	Ground []byte // 'g' / 'd' / 'w'
	Block  []bool
	Height []int8
}

type mapFile struct {
	W      int      `json:"w"`
	H      int      `json:"h"`
	Ground []string `json:"ground"`
	Block  []string `json:"block"`
	Height []string `json:"height"`
}

func LoadMap(path string) (*TileMap, error) {
	raw, err := os.ReadFile(path)
	if err != nil {
		return nil, err
	}
	var f mapFile
	if err := json.Unmarshal(raw, &f); err != nil {
		return nil, err
	}
	if f.W <= 0 || f.H <= 0 ||
		len(f.Ground) != f.H || len(f.Block) != f.H || len(f.Height) != f.H {
		return nil, fmt.Errorf("bad map %s: layer height mismatch", path)
	}

	m := &TileMap{
		W: f.W, H: f.H,
		Ground: make([]byte, f.W*f.H),
		Block:  make([]bool, f.W*f.H),
		Height: make([]int8, f.W*f.H),
	}
	for y := 0; y < f.H; y++ {
		if len(f.Ground[y]) != f.W || len(f.Block[y]) != f.W || len(f.Height[y]) != f.W {
			return nil, fmt.Errorf("bad map %s: row %d width mismatch", path, y)
		}
		for x := 0; x < f.W; x++ {
			i := m.idx(x, y)
			m.Ground[i] = f.Ground[y][x]
			m.Block[i] = f.Block[y][x] == '#'
			m.Height[i] = int8(f.Height[y][x] - '0')
		}
	}
	return m, nil
}

func (m *TileMap) idx(x, y int) int     { return y*m.W + x }
func (m *TileMap) InBounds(x, y int) bool { return x >= 0 && y >= 0 && x < m.W && y < m.H }

func (m *TileMap) HeightAt(x, y int) int8 {
	if !m.InBounds(x, y) {
		return 0
	}
	return m.Height[m.idx(x, y)]
}

func (m *TileMap) Blocked(x, y int) bool {
	if !m.InBounds(x, y) {
		return true // 越界视为墙，省掉所有调用点的边界判断
	}
	return m.Block[m.idx(x, y)]
}

func (m *TileMap) Spawn() Vec2 {
	return Vec2{X: float64(m.W) / 2, Y: float64(m.H) / 2}
}

// CanStand 判定“连续坐标 (x,y) 是否可站立”：目标格不阻塞，且与当前高度差 ≤1。
func (m *TileMap) CanStand(x, y float64, curZ int8) bool {
	tx, ty := int(math.Floor(x)), int(math.Floor(y))
	if m.Blocked(tx, ty) {
		return false
	}
	d := m.HeightAt(tx, ty) - curZ
	return d >= -1 && d <= 1
}

func absInt(n int) int {
	if n < 0 {
		return -n
	}
	return n
}

package game

import "container/heap"

type node struct {
	p    Point
	g    int
	f    int
}

type nodeHeap []*node

func (h nodeHeap) Len() int            { return len(h) }
func (h nodeHeap) Less(i, j int) bool  { return h[i].f < h[j].f }
func (h nodeHeap) Swap(i, j int)       { h[i], h[j] = h[j], h[i] }
func (h *nodeHeap) Push(x any)         { *h = append(*h, x.(*node)) }
func (h *nodeHeap) Pop() any {
	old := *h
	n := old[len(old)-1]
	*h = old[:len(old)-1]
	return n
}

// FindPath 4 邻接 A*；高度差超过 1 视为不可走（与 CanStand 口径一致）。
func (m *TileMap) FindPath(start, goal Point) []Point {
	if m.Blocked(goal.X, goal.Y) {
		return nil
	}
	open := &nodeHeap{}
	heap.Init(open)
	heap.Push(open, &node{p: start, f: absInt(start.X-goal.X) + absInt(start.Y-goal.Y)})

	came := map[Point]Point{}
	g := map[Point]int{start: 0}

	for open.Len() > 0 {
		cur := heap.Pop(open).(*node)
		if cur.p == goal {
			return rebuildPath(came, start, goal)
		}
		if cur.g > g[cur.p] {
			continue // 旧条目，跳过
		}
		for _, d := range [4]Point{{1, 0}, {-1, 0}, {0, 1}, {0, -1}} {
			np := Point{cur.p.X + d.X, cur.p.Y + d.Y}
			if !m.InBounds(np.X, np.Y) || m.Blocked(np.X, np.Y) {
				continue
			}
			if dz := m.HeightAt(np.X, np.Y) - m.HeightAt(cur.p.X, cur.p.Y); dz > 1 || dz < -1 {
				continue
			}
			ng := cur.g + 1
			if old, ok := g[np]; ok && ng >= old {
				continue
			}
			g[np] = ng
			came[np] = cur.p
			heap.Push(open, &node{p: np, g: ng,
				f: ng + absInt(np.X-goal.X) + absInt(np.Y-goal.Y)})
		}
	}
	return nil
}

func rebuildPath(came map[Point]Point, start, goal Point) []Point {
	var rev []Point
	for p := goal; p != start; p = came[p] {
		rev = append(rev, p)
	}
	for i, j := 0, len(rev)-1; i < j; i, j = i+1, j-1 {
		rev[i], rev[j] = rev[j], rev[i]
	}
	return rev
}

// 轴分离移动：X 被墙挡住时仍可沿 Y 滑动，手感更接近真实游戏。
func (r *Room) move(p *Player, mx, my float64, dtMS float64) {
	n := math.Hypot(mx, my)
	if n == 0 {
		return
	}
	if n > 1 {
		mx, my = mx/n, my/n
	}
	step := p.Move.Speed * dtMS / 1000
	dx, dy := mx*step, my*step

	if dx != 0 && r.Map.CanStand(p.Pos.X+dx, p.Pos.Y, p.Z) {
		p.Pos.X += dx
	}
	if dy != 0 && r.Map.CanStand(p.Pos.X, p.Pos.Y+dy, p.Z) {
		p.Pos.Y += dy
	}
	if dx == 0 && dy == 0 {
		return
	}
	p.Z = r.Map.HeightAt(int(p.Pos.X), int(p.Pos.Y))
	p.Dir = dirOf(dx, dy)
	r.dirty[p.ID] = true
}

func dirOf(dx, dy float64) int {
	idx := int(math.Round(math.Atan2(dy, dx) / (math.Pi / 4)))
	if idx < 0 {
		idx += 8
	}
	return idx % 8
}

func (r *Room) stepPlayer(p *Player) {
	if !p.Online() {
		return
	}
	// 每 2 秒回 1 点血；持续效果都应该放在 tick 里，而不是请求里。
	if r.tick%40 == 0 && p.Health.HP < p.Health.MaxHP {
		p.Health.HP++
	}
}

// NPC 巡逻：路径走完后等 2 秒，再按 tick 轮到下一个方向重新寻路。
func (r *Room) stepNPC(n *NPC) {
	if n.Health.HP <= 0 {
		return
	}
	if n.Wait > 0 {
		n.Wait--
		return
	}
	if len(n.Path) == 0 {
		n.Path = r.Map.FindPath(Point{int(n.Pos.X), int(n.Pos.Y)}, r.patrolGoal(n))
		if len(n.Path) == 0 {
			n.Wait = 60
			return
		}
	}

	next := n.Path[0]
	tx, ty := float64(next.X)+0.5, float64(next.Y)+0.5
	dx, dy := tx-n.Pos.X, ty-n.Pos.Y
	d := math.Hypot(dx, dy)
	step := n.Move.Speed * float64(TickInterval.Milliseconds()) / 1000

	if d <= step {
		n.Pos = Vec2{X: tx, Y: ty}
		n.Z = r.Map.HeightAt(next.X, next.Y)
		n.Path = n.Path[1:]
		if len(n.Path) == 0 {
			n.Wait = 120
		}
		return
	}
	n.Pos.X += dx / d * step
	n.Pos.Y += dy / d * step
	n.Z = r.Map.HeightAt(int(n.Pos.X), int(n.Pos.Y))
}

func (r *Room) patrolGoal(n *NPC) Point {
	cx, cy := int(n.Pos.X), int(n.Pos.Y)
	switch int(r.tick/120) % 4 {
	case 0:
		return Point{cx + 6, cy}
	case 1:
		return Point{cx, cy + 6}
	case 2:
		return Point{cx - 6, cy}
	default:
		return Point{cx, cy - 6}
	}
}

// 第 06 章先做“全量广播”，第 08 章再换成 AOI + 事件过滤。
func (r *Room) broadcast() {
	for _, p := range r.players {
		if p.Session == nil {
			continue
		}
		entities := make([]protocol.EntityDTO, 0, len(r.players)+len(r.npcs))
		for _, pl := range r.players {
			if pl.Session != nil {
				entities = append(entities, toDTO(pl.Entity))
			}
		}
		for _, n := range r.npcs {
			entities = append(entities, toDTO(n.Entity))
		}
		data, err := protocol.Encode(protocol.ServerMsg{
			T: "snapshot", Tick: r.tick, Entities: entities,
		})
		if err != nil {
			continue
		}
		if !p.Session.SendMessage(data) {
			p.Session.Close()
			p.Session = nil
			p.OfflineAt = time.Now()
		}
	}
}

func toDTO(e *Entity) protocol.EntityDTO {
	return protocol.EntityDTO{
		ID: string(e.ID), Kind: e.Kind,
		X: e.Pos.X, Y: e.Pos.Y, Z: int(e.Z),
		HP: e.Health.HP, Dir: e.Dir,
	}
}

package game

import "math"

type Skill struct {
	ID            string
	Range         float64 // 格
	HitRadius     float64 // 目标体积补偿
	Damage        int
	CooldownTicks uint64
	LOS           bool // 是否要求视线
}

var skillBook = map[string]Skill{
	"slash": {ID: "slash", Range: 1.8, HitRadius: 0.6, Damage: 12, CooldownTicks: 20},
	"bolt":  {ID: "bolt", Range: 6.0, HitRadius: 0.8, Damage: 18, CooldownTicks: 40, LOS: true},
}

func (r *Room) cast(p *Player, skillID string, targetID EntityID) {
	sk, ok := skillBook[skillID]
	if !ok {
		return
	}
	if r.tick < p.Combat.ReadyAt[skillID] { // 读 nil map 安全，得到 0
		return
	}
	tgt := r.entity(targetID)
	if tgt == nil || tgt.ID == p.ID || tgt.Health.HP <= 0 {
		return
	}
	if math.Hypot(tgt.Pos.X-p.Pos.X, tgt.Pos.Y-p.Pos.Y) > sk.Range+sk.HitRadius {
		return
	}
	if sk.LOS && !r.Map.HasLineOfSight(p.Pos, tgt.Pos, p.Z, tgt.Z) {
		return
	}

	p.Combat.ReadyAt[skillID] = r.tick + sk.CooldownTicks

	// 固定种子的确定性随机：同样的 tick 序列 → 同样的伤害
	dmg := sk.Damage + r.rng.intn(3) - 1
	if dmg < 1 {
		dmg = 1
	}
	_ = tgt.Damage(dmg)

	r.events = append(r.events, Event{Type: "hit", Src: p.ID, Dst: tgt.ID, Amount: dmg})
	if tgt.Health.HP == 0 {
		r.events = append(r.events, Event{Type: "down", Src: p.ID, Dst: tgt.ID})
		r.respawn(tgt)
	}
}

func (r *Room) entity(id EntityID) *Entity {
	if p, ok := r.players[id]; ok && p.Session != nil {
		return p.Entity
	}
	if n, ok := r.npcs[id]; ok {
		return n.Entity
	}
	return nil
}

func (r *Room) respawn(e *Entity) {
	sp := r.Map.Spawn()
	e.Pos = Vec2{X: sp.X, Y: sp.Y}
	e.Z = r.Map.HeightAt(int(sp.X), int(sp.Y))
	e.Health.HP = e.Health.MaxHP
	e.Combat.ReadyAt = map[string]uint64{}
}

// HasLineOfSight 沿 Bresenham 直线检查：中间格不能是墙，也不能高过两端较高点 +1。
func (m *TileMap) HasLineOfSight(a, b Vec2, az, bz int8) bool {
	x0, y0 := int(a.X), int(a.Y)
	x1, y1 := int(b.X), int(b.Y)

	dx := absInt(x1 - x0)
	dy := -absInt(y1 - y0)
	sx, sy := 1, 1
	if x0 > x1 {
		sx = -1
	}
	if y0 > y1 {
		sy = -1
	}

	base := az
	if bz > base {
		base = bz
	}

	err := dx + dy
	for x0 != x1 || y0 != y1 {
		e2 := 2 * err
		if e2 >= dy {
			err += dy
			x0 += sx
		}
		if e2 <= dx {
			err += dx
			y0 += sy
		}
		if m.Blocked(x0, y0) {
			return false
		}
		if m.HeightAt(x0, y0) > base+1 {
			return false
		}
	}
	return true
}

// 确定性随机：xorshift64，种子固定即可完整重放。
type rng struct{ s uint64 }

func newRNG(seed uint64) *rng {
	if seed == 0 {
		seed = 0x9e3779b97f4a7c15
	}
	return &rng{s: seed}
}

func (z *rng) next() uint64 {
	z.s ^= z.s << 13
	z.s ^= z.s >> 7
	z.s ^= z.s << 17
	return z.s
}

func (z *rng) intn(n int) int {
	if n <= 0 {
		return 0
	}
	return int(z.next() % uint64(n))
}

type Room struct {
	// ... 第 05 章字段保持不变
	rng *rng // 新增：房间级确定性随机
}

func NewRoom(id string, tm *TileMap, store SaveStore, log *slog.Logger) *Room {
	return &Room{
		// ... 第 05 章的初始化保持不变
		rng: newRNG(1),
	}
}

package game

import (
	"sort"

	"hd2d/internal/protocol"
)

const (
	AOICellSize  = 16 // 每格 16×16 tile
	AOIViewCells = 1  // 兴趣域 3×3 格
)

func cellOf(p Vec2) (int, int) {
	return int(p.X) / AOICellSize, int(p.Y) / AOICellSize
}

func inView(a, b Vec2) bool {
	ax, ay := cellOf(a)
	bx, by := cellOf(b)
	return absInt(ax-bx) <= AOIViewCells && absInt(ay-by) <= AOIViewCells
}

// visibleTo 返回该玩家可见的实体（含自己）。按 ID 排序，保证测试可复现。
func (r *Room) visibleTo(p *Player) []*Entity {
	out := make([]*Entity, 0, 32)
	out = append(out, p.Entity)

	for _, pl := range r.players {
		if pl.ID != p.ID && pl.Session != nil && inView(p.Pos, pl.Pos) {
			out = append(out, pl.Entity)
		}
	}
	for _, n := range r.npcs {
		if inView(p.Pos, n.Pos) {
			out = append(out, n.Entity)
		}
	}

	sort.Slice(out, func(i, j int) bool { return out[i].ID < out[j].ID })
	return out
}

func (r *Room) eventsFor(p *Player, visible []*Entity) []protocol.EventDTO {
	if len(r.events) == 0 {
		return nil
	}
	set := map[EntityID]bool{p.ID: true}
	for _, e := range visible {
		set[e.ID] = true
	}
	out := make([]protocol.EventDTO, 0, len(r.events))
	for _, ev := range r.events {
		if !set[ev.Src] && !set[ev.Dst] {
			continue // 不相关的战斗事件不发
		}
		out = append(out, protocol.EventDTO{
			Type: ev.Type, Src: string(ev.Src), Dst: string(ev.Dst), Amount: ev.Amount,
		})
	}
	return out
}

func (r *Room) broadcast() {
	for _, p := range r.players {
		if p.Session == nil {
			continue
		}
		visible := r.visibleTo(p)
		entities := make([]protocol.EntityDTO, 0, len(visible))
		for _, e := range visible {
			entities = append(entities, toDTO(e))
		}
		data, err := protocol.Encode(protocol.ServerMsg{
			T:        "snapshot",
			Tick:     r.tick,
			Entities: entities,
			Events:   r.eventsFor(p, visible),
		})
		if err != nil {
			continue
		}
		if !p.Session.SendMessage(data) {
			p.Session.Close()
			p.Session = nil
			p.OfflineAt = time.Now()
			r.dirty[p.ID] = true
		}
	}
}

package game

import (
	"context"
	"time"
)

const OfflineGrace = 30 * time.Second

// addPlayer 替换第 05 章版本：新增“同 token 重连”与“从存档恢复”。
func (r *Room) addPlayer(req joinReq) {
	// 1) 房间里还有同 token 的离线玩家 → 直接复用，这就是重连
	if req.Token != "" {
		if p, ok := r.tokens[req.Token]; ok {
			p.Session = req.Sess
			p.OfflineAt = time.Time{}
			r.dirty[p.ID] = true
			req.Sess.SendMessage(welcomeMsg(p, p.Token))
			req.Done <- joinResult{ID: p.ID}
			r.Log.Info("player reconnected", "id", p.ID)
			return
		}
	}

	// 2) 新玩家：生成 token，尝试从存档恢复
	token := req.Token
	if token == "" {
		token = randomToken()
	}
	sp := r.Map.Spawn()
	sv := Save{
		Token: token, MapID: r.ID,
		X: sp.X, Y: sp.Y, Z: r.Map.HeightAt(int(sp.X), int(sp.Y)), HP: 100,
	}
	// 读档是同步 IO：教学版简化放在 tick 里；生产应在 Join 之前由网络协程读档，
	// 再把 Save 作为 joinReq 的一部分传进来，避免 DB 抖动拖慢整帧。
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	if loaded, ok, err := r.Store.Load(ctx, token); err == nil && ok && loaded.MapID == r.ID {
		sv = loaded
	}

	p := &Player{
		Entity: &Entity{
			ID:   EntityID("p-" + shortID(token)),
			Kind: "player",
			Pos:  Vec2{X: sv.X, Y: sv.Y},
			Z:    sv.Z,
			Move: MoveComp{Speed: 4.0},
			Health: HealthComp{HP: sv.HP, MaxHP: 100},
			Combat: CombatComp{ReadyAt: map[string]uint64{}},
		},
		Token:   token,
		Session: req.Sess,
	}
	r.players[p.ID] = p
	r.tokens[token] = p
	r.dirty[p.ID] = true
	req.Sess.SendMessage(welcomeMsg(p, token))
	req.Done <- joinResult{ID: p.ID}
}

// welcomeMsg 统一 welcome 帧格式，新玩家与重连都复用。
func welcomeMsg(p *Player, token string) []byte {
	out, _ := protocol.Encode(protocol.ServerMsg{
		T: "welcome", PID: string(p.ID), Token: token, TickRate: TickRate,
	})
	return out
}

func (r *Room) markOffline(id EntityID) {
	p, ok := r.players[id]
	if !ok || p.Session == nil {
		return
	}
	p.Session = nil
	p.OfflineAt = time.Now()
	r.dirty[id] = true
}

// 在 step 末尾调用：断线超过宽限期才真正移除并落盘。
func (r *Room) expireOffline() {
	now := time.Now()
	for id, p := range r.players {
		if p.Session != nil || p.OfflineAt.IsZero() || now.Sub(p.OfflineAt) < OfflineGrace {
			continue
		}
		r.persistPlayer(context.Background(), p)
		delete(r.players, id)
		delete(r.tokens, p.Token)
		delete(r.dirty, id)
		r.Log.Info("player expired", "id", id)
	}
}

func (r *Room) persistPlayer(ctx context.Context, p *Player) {
	err := r.Store.Upsert(ctx, Save{
		Token: p.Token, MapID: r.ID,
		X: p.Pos.X, Y: p.Pos.Y, Z: p.Z, HP: p.Health.HP,
		Updated: time.Now().Unix(),
	})
	if err != nil {
		r.Log.Error("save player", "id", p.ID, "err", err)
	}
}

func (r *Room) persistDirty(ctx context.Context) {
	for id := range r.dirty {
		p, ok := r.players[id]
		if !ok {
			delete(r.dirty, id)
			continue
		}
		r.persistPlayer(ctx, p)
		delete(r.dirty, id)
	}
}

func (r *Room) step() {
	r.drain()
	r.tick++
	// ... 原有移动 / NPC 逻辑
	r.expireOffline()
	if r.tick%600 == 0 { // 每 30 秒落一次脏数据
		r.persistDirty(context.Background())
	}
	// ... 原有的快照广播
}

type ServerMsg struct {
	// ... 原有字段
	Removed []string `json:"removed,omitempty"` // 本次离开 AOI 的实体
}

package persist

import (
	"context"
	"database/sql"

	_ "modernc.org/sqlite" // 纯 Go 驱动，注册驱动名 "sqlite"

	"hd2d/internal/game"
)

type Store struct{ db *sql.DB }

const schema = `
CREATE TABLE IF NOT EXISTS players (
  token      TEXT PRIMARY KEY,
  map_id     TEXT    NOT NULL,
  x          REAL    NOT NULL,
  y          REAL    NOT NULL,
  z          INTEGER NOT NULL,
  hp         INTEGER NOT NULL,
  updated_at INTEGER NOT NULL
);`

func Open(path string) (*Store, error) {
	dsn := "file:" + path + "?_pragma=busy_timeout(5000)&_pragma=journal_mode(WAL)"
	db, err := sql.Open("sqlite", dsn)
	if err != nil {
		return nil, err
	}
	// SQLite 同一时刻只允许一个写者；教学场景直接串行化，避免 SQLITE_BUSY。
	db.SetMaxOpenConns(1)
	if _, err := db.Exec(schema); err != nil {
		_ = db.Close()
		return nil, err
	}
	return &Store{db: db}, nil
}

func (s *Store) Close() error { return s.db.Close() }

func (s *Store) Load(ctx context.Context, token string) (game.Save, bool, error) {
	var sv game.Save
	err := s.db.QueryRowContext(ctx,
		`SELECT map_id, x, y, z, hp, updated_at FROM players WHERE token = ?`, token,
	).Scan(&sv.MapID, &sv.X, &sv.Y, &sv.Z, &sv.HP, &sv.Updated)
	if err == sql.ErrNoRows {
		return game.Save{}, false, nil
	}
	if err != nil {
		return game.Save{}, false, err
	}
	sv.Token = token
	return sv, true, nil
}

func (s *Store) Upsert(ctx context.Context, sv game.Save) error {
	_, err := s.db.ExecContext(ctx, `
INSERT INTO players (token, map_id, x, y, z, hp, updated_at)
VALUES (?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(token) DO UPDATE SET
  map_id     = excluded.map_id,
  x          = excluded.x,
  y          = excluded.y,
  z          = excluded.z,
  hp         = excluded.hp,
  updated_at = excluded.updated_at`,
		sv.Token, sv.MapID, sv.X, sv.Y, sv.Z, sv.HP, sv.Updated)
	return err
}

// 这段装配放在第 03 章 main 的 ctx/stop 创建之后；worldDone 供停机收尾使用。
store, err := persist.Open(cfg.DBPath)
if err != nil {
	log.Error("open store", "err", err)
	os.Exit(1)
}
defer store.Close()

tm, err := game.LoadMap("testdata/maps/lobby.json")
if err != nil {
	log.Error("load map", "err", err)
	os.Exit(1)
}

world := game.NewWorld(store, log)
room := game.NewRoom("lobby", tm, store, log)
room.AddNPC(game.NewNPC("npc-1", game.Vec2{X: 30, Y: 20}, 0))
room.AddNPC(game.NewNPC("npc-2", game.Vec2{X: 44, Y: 28}, 1))
world.AddRoom(room)

// worldDone 用于停机时等待所有房间落盘完成
worldDone := make(chan struct{})
go func() {
	defer close(worldDone)
	world.Run(ctx)
}()

mux.HandleFunc("GET /ws", func(w http.ResponseWriter, r *http.Request) {
	token := r.URL.Query().Get("token") // 首次为空；重连带上次 welcome 返回的 token
	netws.ServeWS(w, r, log, func(c *netws.Client) {
		go c.WritePump()

		id, err := room.Join(r.Context(), token, c)
		if err != nil {
			log.Warn("join failed", "err", err)
			c.Close()
			return
		}

		c.ReadPump(func(m protocol.ClientMsg) error {
			if !room.Submit(id, m) {
				// 队列满：先丢弃并记日志；第 10 章把它换成 InputsDropped.Add(1)
				log.Warn("input dropped", "player", id)
			}
			return nil
		})

		room.Leave(id)
		c.Close()
	})
})

<-ctx.Done()
shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
_ = srv.Shutdown(shutdownCtx) // 1. 停止接收新连接，等在途请求结束
<-worldDone                   // 2. 等所有房间 tick 退出并完成落盘
log.Info("bye")               // 3. 最后才退出进程

func NewNPC(id EntityID, at Vec2, z int8) *NPC {
	return &NPC{Entity: &Entity{
		ID: id, Kind: "npc",
		Pos:    at,
		Z:      z,
		Move:   MoveComp{Speed: 1.5},
		Health: HealthComp{HP: 60, MaxHP: 60},
		Combat: CombatComp{ReadyAt: map[string]uint64{}},
	}}
}

// AddNPC 只能在世界启动前调用；启动后请通过 join 命令扩展。
func (r *Room) AddNPC(n *NPC) { r.npcs[n.ID] = n }

package game

import "testing"

func testMap() *TileMap {
	m := &TileMap{
		W: 8, H: 8,
		Ground: make([]byte, 64),
		Block:  make([]bool, 64),
		Height: make([]int8, 64),
	}
	m.Block[m.idx(2, 1)] = true  // 一堵墙
	m.Height[m.idx(1, 2)] = 2    // 一格高台
	return m
}

func TestCanStand(t *testing.T) {
	m := testMap()
	cases := []struct {
		name string
		x, y float64
		z    int8
		want bool
	}{
		{"平地可站", 0.2, 0.2, 0, true},
		{"墙不可站", 2.2, 1.2, 0, false},
		{"台阶太高", 1.2, 2.2, 0, false},
		{"下台阶允许", 1.2, 2.2, 3, true},
		{"越界不可站", 9.0, 9.0, 0, false},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			if got := m.CanStand(tc.x, tc.y, tc.z); got != tc.want {
				t.Fatalf("CanStand(%v,%v,%d)=%v, want %v", tc.x, tc.y, tc.z, got, tc.want)
			}
		})
	}
}

package game

import (
	"context"
	"encoding/json"
	"log/slog"
	"testing"
	"time"

	"hd2d/internal/protocol"
)

type fakeSession struct{ send chan []byte }

func (f *fakeSession) SendMessage(b []byte) bool {
	select {
	case f.send <- b:
		return true
	default:
		return false
	}
}
func (f *fakeSession) Close() {}

type memStore struct{}

func (memStore) Load(context.Context, string) (Save, bool, error) { return Save{}, false, nil }
func (memStore) Upsert(context.Context, Save) error               { return nil }

func TestJoinReceivesSnapshot(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	room := NewRoom("test", testMap(), memStore{}, slog.Default())
	go room.Run(ctx)

	sess := &fakeSession{send: make(chan []byte, 16)}
	id, err := room.Join(ctx, "", sess)
	if err != nil || id == "" {
		t.Fatalf("join: id=%q err=%v", id, err)
	}

	// welcome 之后才会有 snapshot，所以要循环读到快照帧为止。
	deadline := time.After(300 * time.Millisecond)
	for {
		select {
		case raw := <-sess.send:
			var m protocol.ServerMsg
			if err := json.Unmarshal(raw, &m); err != nil {
				continue
			}
			if m.T == "snapshot" && len(m.Entities) > 0 {
				return
			}
		case <-deadline:
			t.Fatal("no snapshot within 300ms")
		}
	}
}

package observability

import (
	"fmt"
	"net/http"
	"sync/atomic"
)

var (
	TicksTotal    atomic.Uint64
	TickOverruns  atomic.Uint64
	InputsDropped atomic.Uint64
	PlayersOnline atomic.Int64
)

func Handler() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "text/plain; version=0.0.4; charset=utf-8")
		fmt.Fprintf(w, "# TYPE hd2d_ticks_total counter\nhd2d_ticks_total %d\n", TicksTotal.Load())
		fmt.Fprintf(w, "# TYPE hd2d_tick_overruns_total counter\nhd2d_tick_overruns_total %d\n", TickOverruns.Load())
		fmt.Fprintf(w, "# TYPE hd2d_inputs_dropped_total counter\nhd2d_inputs_dropped_total %d\n", InputsDropped.Load())
		fmt.Fprintf(w, "# TYPE hd2d_players_online gauge\nhd2d_players_online %d\n", PlayersOnline.Load())
	}
}

import "net/http/pprof"

admin := http.NewServeMux()
admin.HandleFunc("/debug/pprof/", pprof.Index)
admin.HandleFunc("/debug/pprof/profile", pprof.Profile)
admin.Handle("/debug/pprof/heap", pprof.Handler("heap"))
go func() {
	if err := http.ListenAndServe("127.0.0.1:6060", admin); err != nil {
		log.Warn("pprof server", "err", err)
	}
}()

package main

import (
	"flag"
	"fmt"
	"log"
	"sync"
	"time"

	"github.com/gorilla/websocket"

	"hd2d/internal/protocol"
)

func main() {
	addr := flag.String("addr", "ws://127.0.0.1:8080/ws", "server ws url")
	n := flag.Int("n", 2, "number of bots")
	flag.Parse()

	var wg sync.WaitGroup
	for i := 0; i < *n; i++ {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			runBot(i, *addr)
		}(i)
		time.Sleep(50 * time.Millisecond) // 错峰连接，避免瞬时握手风暴
	}
	wg.Wait()
}

func runBot(i int, addr string) {
	conn, _, err := websocket.DefaultDialer.Dial(addr, nil)
	if err != nil {
		log.Printf("bot %d dial: %v", i, err)
		return
	}
	defer conn.Close()

	go func() {
		snaps := 0
		for {
			var m protocol.ServerMsg
			if err := conn.ReadJSON(&m); err != nil {
				return
			}
			if m.T == "welcome" {
				fmt.Printf("bot %d welcome pid=%s tickRate=%d\n", i, m.PID, m.TickRate)
			}
			if m.T == "snapshot" {
				snaps++
				if snaps%20 == 0 { // 10Hz 下每 2 秒打印一次，压测时才不会刷爆 stdout
					fmt.Printf("bot %d tick=%d entities=%d\n", i, m.Tick, len(m.Entities))
				}
			}
		}
	}()

	t := time.NewTicker(50 * time.Millisecond)
	defer t.Stop()
	var seq int64
	for range t.C {
		seq++
		msg := protocol.ClientMsg{T: "input", Seq: seq, DT: 50, MX: float64(i % 3-1), MY: 1}
		if err := conn.WriteJSON(msg); err != nil {
			return
		}
	}
}

FROM golang:1.22-alpine AS build
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/hd2d ./cmd/server

FROM alpine:3.20
RUN adduser -D -u 10001 app \
 && mkdir -p /app/data \
 && chown -R app /app
WORKDIR /app
USER app
COPY --from=build /out/hd2d /app/hd2d
COPY --from=build /src/testdata /app/testdata
ENV HD2D_ADDR=:8080 \
    HD2D_DB=/app/data/hd2d.db
EXPOSE 8080
ENTRYPOINT ["/app/hd2d"]

docker build -t hd2d-server:dev .
docker run --rm --name hd2d-server -p 8080:8080 -v hd2d-data:/app/data hd2d-server:dev

# 优雅重启验证：容器收到 SIGTERM 后应完成落盘再退出
docker stop --time 10 hd2d-server

package game

import (
	"hash/fnv"
)

// ShardOf 用一致性哈希把 mapId 映射到 shard，网关据此决定连接落到哪个实例。
func ShardOf(mapID string, shards int) int {
	h := fnv.New32a()
	_, _ = h.Write([]byte(mapID))
	return int(h.Sum32() % uint32(shards))
}

# 1. 生成地图（首次或改地图后）
go run ./cmd/mapgen

# 2. 质量门禁
go fmt ./...
go vet ./...
go test -race ./...

# 3. 起服务
go run ./cmd/server

# 4. 另开终端：双人
go run ./cmd/bot -n 2

# 5. 容量
go run ./cmd/bot -n 100

# 6. 观测
curl http://127.0.0.1:8080/metrics