ngzz-mc/internal/game/game.go

// Package game 游戏会话：输入 → 玩家 → 世界 → 交互（破坏/放置）的粘合层（架构.md §3 主循环）。
//
// 职责边界：会话只做调度与玩法逻辑，渲染/UI/网络通过接口或外部驱动访问。
package game

import (
	"time"

	"mc/internal/block"
	"mc/internal/camera"
	"mc/internal/inventory"
	"mc/internal/item"
	"mc/internal/physics"
	"mc/internal/raycast"
	"mc/internal/recipe"
	"mc/internal/world"
)

// Session 单机游戏会话。
type Session struct {
	World   *world.World
	Reg     *block.Registry
	Items   *item.Registry
	Recipes *recipe.Registry
	Player  *physics.Player
	Inv     *inventory.Inventory
	Cam     *camera.Camera

	// 破坏进度状态（方块交互与动画.md §3）
	breakTarget raycast.Hit
	breaking    bool
	breakProg   float64

	// 创造模式（跳过进度直接破坏）
	Creative bool
}

// NewSession 创建会话。
func NewSession(w *world.World, reg *block.Registry, items *item.Registry, recipes *recipe.Registry, p *physics.Player, inv *inventory.Inventory, cam *camera.Camera) *Session {
	return &Session{World: w, Reg: reg, Items: items, Recipes: recipes, Player: p, Inv: inv, Cam: cam}
}

// Tick 每 tick（20Hz）会话逻辑（架构.md §3.2）。
func (s *Session) Tick(dt float64) {
	// 物理积分（速度由输入层写入 Player.Vel）
	s.Player.Tick(s.World, dt)
	// 区块调度（主线程预算 8ms，区块管理.md §4.3）
	s.World.Update(s.Player.Pos[0], s.Player.Pos[1], s.Player.Pos[2], 8*time.Millisecond)
	// 破坏进度累积
	if s.breaking {
		s.accumulateBreak(dt)
	}
	// 相机跟随玩家眼睛
	s.Cam.Pos = s.Player.Eye()
}

// Cast 从相机射线拾取（方块交互与动画.md §2）。
func (s *Session) Cast(maxDist float64) (raycast.Hit, bool) {
	f := s.Cam.Forward()
	return raycast.Cast(s.Cam.Pos, f, maxDist, func(x, y, z int32) bool {
		return s.Reg.IsSolid(s.World.Block(x, y, z))
	})
}

// BeginBreak 按下左键：锁定破坏目标（进度从 0 开始）。
func (s *Session) BeginBreak() {
	h, ok := s.Cast(5)
	if !ok {
		s.EndBreak()
		return
	}
	s.breakTarget = h
	s.breaking = true
	s.breakProg = 0
	if s.Creative {
		s.BreakNow()
	}
}

// EndBreak 松开左键/换目标：进度清零。
func (s *Session) EndBreak() {
	s.breaking = false
	s.breakProg = 0
	s.breakTarget = raycast.Hit{}
}

// BreakProgress 当前破坏进度（0–1，UI 裂纹用）。
func (s *Session) BreakProgress() float64 { return s.breakProg }

// BreakTarget 当前破坏目标（渲染选择框/裂纹用）。
func (s *Session) BreakTarget() raycast.Hit { return s.breakTarget }

// breakSpeed 每秒破坏进度（方块交互与动画.md §3、挖矿与矿物.md §3 同公式）。
func (s *Session) breakSpeed(def block.Def, tool item.Stack) float64 {
	speed := 1.0 // 空手
	if !tool.Empty() {
		if d, ok := s.Items.Get(tool.Name); ok && d.Tool != "" {
			if d.Tier >= def.RequiredTier {
				speed = d.Speed
			} else {
				speed = 0.05 // 工具门槛不足：极慢（挖矿与矿物.md §3 slow 策略）
			}
		}
	}
	if def.Hardness <= 0 {
		return 1e9 // 不可破坏（如基岩 hardness=-1 → 瞬时？不：返回 0 更合理）
	}
	return speed / def.Hardness
}

// accumulateBreak 累积破坏进度，完成即摧毁（掉落进背包 + 耐久消耗）。
func (s *Session) accumulateBreak(dt float64) {
	st := s.World.Block(s.breakTarget.X, s.breakTarget.Y, s.breakTarget.Z)
	def := s.Reg.Get(st.ID())
	if def.ID == 0 {
		s.EndBreak() // 目标已消失
		return
	}
	tool := s.Inv.SelectedStack()
	s.breakProg += s.breakSpeed(def, tool) * dt
	if s.breakProg >= 1.0 {
		s.destroy(s.breakTarget)
		s.EndBreak()
	}
}

// destroy 摧毁方块：替换为空气 + 掉落进背包（工具耐久后置）。
func (s *Session) destroy(h raycast.Hit) {
	st := s.World.Block(h.X, h.Y, h.Z)
	def := s.Reg.Get(st.ID())
	s.World.SetBlock(h.X, h.Y, h.Z, block.Air)
	drop := def.Drops
	if drop == "" {
		drop = def.Name
	}
	if drop != "" {
		rem := s.Inv.Add(item.Stack{Name: drop, Count: 1})
		_ = rem // 背包满则丢弃（后置：掉落实体）
	}
}

// BreakNow 立即破坏（创造模式）。
func (s *Session) BreakNow() {
	if !s.breaking {
		return
	}
	s.destroy(s.breakTarget)
	s.EndBreak()
}

// PlaceSelected 放置选中槽物品（右键，方块交互与动画.md §6）。
func (s *Session) PlaceSelected() {
	sel := s.Inv.SelectedStack()
	if sel.Empty() {
		return
	}
	d, ok := s.Items.Get(sel.Name)
	if !ok || d.Place == "" {
		return
	}
	bid, ok := s.Reg.ID(d.Place)
	if !ok {
		return
	}
	// 射线拾取放置位
	h, ok := s.Cast(5)
	if !ok {
		return
	}
	px, py, pz := h.Prev[0], h.Prev[1], h.Prev[2]
	// 目标必须为空且不与玩家 AABB 重叠（方块交互与动画.md §10 踩坑）
	if s.World.Block(px, py, pz) != block.Air {
		return
	}
	if s.overlapsPlayer(px, py, pz) {
		return
	}
	s.World.SetBlock(px, py, pz, block.NewState(bid, 0))
	// 消耗一个物品
	s.Inv.Remove(sel.Name, 1)
}

// overlapsPlayer 放置位是否与玩家 AABB 重叠。
func (s *Session) overlapsPlayer(x, y, z int32) bool {
	p := s.Player
	px, py, pz := p.Pos[0], p.Pos[1], p.Pos[2]
	hw := p.Width / 2
	// 方块 AABB [x,x+1]×[y,y+1]×[z,z+1] 与玩家 AABB 相交判定
	return float64(x)+1 > px-hw && float64(x) < px+hw &&
		float64(y)+1 > py && float64(y) < py+p.Height &&
		float64(z)+1 > pz-hw && float64(z) < pz+hw
}