タイル情報を表示するstateを追加した (#360)

ゲームプレイ上はもちろん、デバッグにも便利なので作成した

Author: kijimad

README.md

@@ -17,6 +17,8 @@
 
 <img src="./vrtimages/DebugMenu.png" width="50%" /><img src="./vrtimages/ShopMenu.png" width="50%" />
 
+<img src="./vrtimages/LookAround.png" width="50%" />
+
 各画像は全自動でキャプチャされる。最新なことをCIで保証している。
 
 ## キーボード操作

internal/cmd/screenshot.go

@@ -39,11 +39,11 @@ func runScreenshot(_ context.Context, cmd *cli.Command) error {
 			Depth:       1,
 			BuilderType: mapplanner.PlannerTypeSmallRoom,
 		})
-	case gs.FieldInfoState{}.String():
+	case gs.LookAroundState{}.String():
 		return vrt.RunTestGame(mode, &gs.DungeonState{
 			Depth:       1,
 			BuilderType: mapplanner.PlannerTypeSmallRoom,
-		}, &gs.FieldInfoState{})
+		}, &gs.LookAroundState{})
 	case gs.EquipMenuState{}.String():
 		return vrt.RunTestGame(mode, townStateFactory(), &gs.EquipMenuState{})
 	case "GameOver":

internal/consts/coord.go

@@ -0,0 +1,12 @@
+package consts
+
+// Numeric は座標で使用可能な数値型を定義する
+type Numeric interface {
+	~int | ~float64
+}
+
+// Coord は2次元座標を表すジェネリック型
+type Coord[T Numeric] struct {
+	X T
+	Y T
+}

internal/engine/states/lib.go

@@ -60,21 +60,10 @@ type ActionHandler[T any] interface {
 // StateFactory はステートを作成するファクトリー関数の型
 type StateFactory[T any] func() State[T]
 
-// DrawHook はstate描画時のフック関数
-// stateIndex: 現在描画したstateのインデックス
-// stateCount: 現在のstateの総数
-type DrawHook[T any] func(
-	stateIndex int,
-	stateCount int,
-	world T,
-	screen *ebiten.Image,
-) error
-
 // StateMachine はジェネリックな状態スタックを管理する
 type StateMachine[T any] struct {
 	states         []State[T]
 	lastTransition Transition[T]
-	AfterDrawHook  DrawHook[T]
 }
 
 // Init は新しいステートマシンを初期化する
@@ -133,20 +122,11 @@ func (sm *StateMachine[T]) Update(world T) error {
 
 // Draw は画面を描画する
 func (sm *StateMachine[T]) Draw(world T, screen *ebiten.Image) error {
-	stateCount := len(sm.states)
-	for i, state := range sm.states {
+	for _, state := range sm.states {
 		if err := state.Draw(world, screen); err != nil {
 			return err
 		}
-
-		// 各state描画後にフックを呼び出し
-		if sm.AfterDrawHook != nil {
-			if err := sm.AfterDrawHook(i, stateCount, world, screen); err != nil {
-				return err
-			}
-		}
 	}
-
 	return nil
 }
 
@@ -276,7 +256,7 @@ func (sm *StateMachine[T]) quit(world T) error {
 	return nil
 }
 
-// GetStates はステートスタックのコピーを返す（テスト用）
+// GetStates はステートスタックのコピーを返す
 func (sm *StateMachine[T]) GetStates() []State[T] {
 	states := make([]State[T], len(sm.states))
 	copy(states, sm.states)

internal/maingame/game.go

@@ -18,6 +18,7 @@ import (
 	"github.com/kijimaD/ruins/internal/loader"
 	gr "github.com/kijimaD/ruins/internal/resources"
 	"github.com/kijimaD/ruins/internal/screeneffect"
+	"github.com/kijimaD/ruins/internal/states"
 	gs "github.com/kijimaD/ruins/internal/systems"
 	w "github.com/kijimaD/ruins/internal/world"
 )
@@ -31,9 +32,6 @@ type MainGame struct {
 
 // NewMainGame はMainGameを初期化する
 func NewMainGame(world w.World, stateMachine es.StateMachine[w.World]) (*MainGame, error) {
-	// オーバーレイ描画フックを設定
-	stateMachine.AfterDrawHook = afterDrawHook
-
 	retroFilter, err := screeneffect.NewRetroFilter()
 	if err != nil {
 		return nil, fmt.Errorf("レトロフィルタの初期化に失敗: %w", err)
@@ -73,6 +71,7 @@ func (game *MainGame) Update() error {
 }
 
 // Draw はゲームの描画処理を行う
+// interface method だからシグネチャは変更できない
 func (game *MainGame) Draw(screen *ebiten.Image) {
 	bounds := screen.Bounds()
 	offscreen := game.screenPipeline.Begin(bounds.Dx(), bounds.Dy())
@@ -83,8 +82,20 @@ func (game *MainGame) Draw(screen *ebiten.Image) {
 		target = screen
 	}
 
-	if err := game.StateMachine.Draw(game.World, target); err != nil {
-		log.Fatal(err)
+	// stateを描画し、必要に応じてブラーオーバーレイを適用する
+	stateList := game.StateMachine.GetStates()
+	for i, state := range stateList {
+		if err := state.Draw(game.World, target); err != nil {
+			log.Fatal(err)
+		}
+
+		// 複数stateがあるとき、最初のstate描画後にブラーを適用する
+		if i == 0 && len(stateList) > 1 {
+			topState := stateList[len(stateList)-1]
+			if cfg, ok := topState.(states.Configurable); !ok || cfg.StateConfig().BlurBackground {
+				applyBlurOverlay(target, state)
+			}
+		}
 	}
 
 	if game.World.Config.ShowMonitor {

internal/maingame/hooks.go

@@ -4,74 +4,71 @@ import (
 	"image/color"
 
 	"github.com/hajimehoshi/ebiten/v2"
-	"github.com/hajimehoshi/ebiten/v2/vector"
+	es "github.com/kijimaD/ruins/internal/engine/states"
 	w "github.com/kijimaD/ruins/internal/world"
 )
 
-// ブラー画像と黒背景のキャッシュ
+// ブラー画像と暗転オーバーレイのキャッシュ
 var (
-	cachedBlurImage       *ebiten.Image
-	cachedBlackBackground *ebiten.Image
-	cachedStateCount      int
+	cachedBlurImage   *ebiten.Image
+	cachedDarkOverlay *ebiten.Image
+	cachedBaseState   es.State[w.World]
 )
 
-// afterDrawHook は各stateのDraw完了後に呼ばれるフック関数
-func afterDrawHook(stateIndex, stateCount int, _ w.World, screen *ebiten.Image) error {
-	if cachedStateCount != stateCount {
-		// キャッシュをクリア
+// applyBlurOverlay は画面にブラー効果を適用する
+// baseStateが変わるとキャッシュを再生成する
+func applyBlurOverlay(screen *ebiten.Image, baseState es.State[w.World]) {
+	// 下層stateが変わったらキャッシュをクリア
+	if cachedBaseState != baseState {
 		cachedBlurImage = nil
-		cachedStateCount = stateCount
+		cachedBaseState = baseState
 	}
 
-	// stateが複数あるとき初回のstate描画後に1回だけブラー効果を適用する
-	if stateCount > 1 && stateIndex == 0 {
-		bounds := screen.Bounds()
+	bounds := screen.Bounds()
 
-		// キャッシュがない場合のみブラー処理を実行
-		if cachedBlurImage == nil {
-			// 現在の画面をコピー
-			src := ebiten.NewImage(bounds.Dx(), bounds.Dy())
-			src.DrawImage(screen, nil)
+	// キャッシュがない場合のみブラー画像を生成する
+	if cachedBlurImage == nil {
+		w, h := bounds.Dx(), bounds.Dy()
 
-			// ブラー効果を2パス（水平→垂直）で適用
-			// 水平ブラー
-			const blurRadius = 4
-			tmp := ebiten.NewImage(bounds.Dx(), bounds.Dy())
-			for x := -blurRadius; x <= blurRadius; x++ {
-				op := &ebiten.DrawImageOptions{}
-				op.GeoM.Translate(float64(x), 0)
-				op.ColorScale.ScaleAlpha(1.0 / float32(blurRadius*2+1))
-				op.Blend = ebiten.BlendSourceOver
-				tmp.DrawImage(src, op)
-			}
+		// 現在の画面をコピーする
+		src := ebiten.NewImage(w, h)
+		op := &ebiten.DrawImageOptions{}
+		op.GeoM.Translate(float64(-bounds.Min.X), float64(-bounds.Min.Y))
+		src.DrawImage(screen, op)
 
-			// 垂直ブラー
-			cachedBlurImage = ebiten.NewImage(bounds.Dx(), bounds.Dy())
-			for y := -blurRadius; y <= blurRadius; y++ {
-				op := &ebiten.DrawImageOptions{}
-				op.GeoM.Translate(0, float64(y))
-				op.ColorScale.ScaleAlpha(1.0 / float32(blurRadius*2+1))
-				op.Blend = ebiten.BlendSourceOver
-				cachedBlurImage.DrawImage(tmp, op)
-			}
-		}
+		// ブラー効果を2パス（水平→垂直）で適用する
+		const blurRadius = 4
+		kernel := blurRadius*2 + 1
 
-		// 黒い背景画像をキャッシュから取得または生成
-		if cachedBlackBackground == nil {
-			cachedBlackBackground = ebiten.NewImage(bounds.Dx(), bounds.Dy())
-			width := float32(bounds.Dx())
-			height := float32(bounds.Dy())
-			vector.FillRect(cachedBlackBackground, 0, 0, width, height, color.RGBA{0, 0, 0, 255}, false)
+		// 水平ブラー
+		tmp := ebiten.NewImage(bounds.Dx(), bounds.Dy())
+		for x := -blurRadius; x <= blurRadius; x++ {
+			op := &ebiten.DrawImageOptions{}
+			op.GeoM.Translate(float64(x), 0)
+			op.ColorScale.Scale(1.0/float32(kernel), 1.0/float32(kernel), 1.0/float32(kernel), 1.0/float32(kernel))
+			op.Blend = ebiten.BlendLighter
+			tmp.DrawImage(src, op)
 		}
 
-		screen.Clear()
-
-		// 黒背景を描画
-		screen.DrawImage(cachedBlackBackground, nil)
+		// 垂直ブラー
+		cachedBlurImage = ebiten.NewImage(bounds.Dx(), bounds.Dy())
+		for y := -blurRadius; y <= blurRadius; y++ {
+			op := &ebiten.DrawImageOptions{}
+			op.GeoM.Translate(0, float64(y))
+			op.ColorScale.Scale(1.0/float32(kernel), 1.0/float32(kernel), 1.0/float32(kernel), 1.0/float32(kernel))
+			op.Blend = ebiten.BlendLighter
+			cachedBlurImage.DrawImage(tmp, op)
+		}
+	}
 
-		// その上にブラー画像を描画
-		screen.DrawImage(cachedBlurImage, nil)
+	// 黒い半透明オーバーレイをキャッシュから取得または生成する
+	if cachedDarkOverlay == nil {
+		cachedDarkOverlay = ebiten.NewImage(bounds.Dx(), bounds.Dy())
+		cachedDarkOverlay.Fill(color.RGBA{0, 0, 0, 48})
 	}
 
-	return nil
+	drawOp := &ebiten.DrawImageOptions{}
+	drawOp.GeoM.Translate(float64(bounds.Min.X), float64(bounds.Min.Y))
+	screen.DrawImage(cachedBlurImage, drawOp)
+	screen.DrawImage(cachedDarkOverlay, drawOp)
 }

internal/mapplanner/hostile_npc_planner.go

@@ -19,7 +19,7 @@ const (
 
 // NPCSpec はNPC配置仕様を表す
 type NPCSpec struct {
-	Coord
+	consts.Coord[int]
 	Name string // NPCタイプ
 }
 
@@ -78,7 +78,7 @@ func (n *HostileNPCPlanner) PlanMeta(planData *MetaPlan) error {
 		}
 
 		planData.NPCs = append(planData.NPCs, NPCSpec{
-			Coord: Coord{X: int(tx), Y: int(ty)},
+			Coord: consts.Coord[int]{X: int(tx), Y: int(ty)},
 			Name:  enemyName,
 		})
 

internal/mapplanner/item_planner.go

@@ -21,7 +21,7 @@ const (
 
 // ItemSpec はアイテム配置仕様を表す
 type ItemSpec struct {
-	Coord
+	consts.Coord[int]
 	Name string // アイテム名
 }
 
@@ -100,7 +100,7 @@ func (i *ItemPlanner) addItem(planData *MetaPlan, itemName string) error {
 
 		// MetaPlanにアイテムを追加
 		planData.Items = append(planData.Items, ItemSpec{
-			Coord: Coord{X: int(x), Y: int(y)},
+			Coord: consts.Coord[int]{X: int(x), Y: int(y)},
 			Name:  itemName,
 		})
 

internal/mapplanner/lib.go

@@ -15,15 +15,9 @@ import (
 	w "github.com/kijimaD/ruins/internal/world"
 )
 
-// Coord はタイル座標を表す
-type Coord struct {
-	X int
-	Y int
-}
-
 // PropsSpec はProps配置仕様を表す
 type PropsSpec struct {
-	Coord
+	consts.Coord[int]
 	Name string // Prop名
 }
 
@@ -43,9 +37,9 @@ type MetaPlan struct {
 	// 通行可能かを判定するための情報を保持している必要がある
 	Tiles []raw.TileRaw
 	// NextPortals は次の階へ進むポータルリスト
-	NextPortals []Coord
+	NextPortals []consts.Coord[int]
 	// EscapePortals は脱出用ポータルリスト
-	EscapePortals []Coord
+	EscapePortals []consts.Coord[int]
 	// NPCs は配置予定のNPCリスト
 	NPCs []NPCSpec
 	// Items は配置予定のアイテムリスト
@@ -298,8 +292,8 @@ func NewPlannerChain(width consts.Tile, height consts.Tile, seed uint64) *Planne
 			Rooms:         []gc.Rect{},
 			Corridors:     [][]resources.TileIdx{},
 			RNG:           rand.New(rand.NewPCG(seed, seed+1)),
-			NextPortals:   []Coord{},
-			EscapePortals: []Coord{},
+			NextPortals:   []consts.Coord[int]{},
+			EscapePortals: []consts.Coord[int]{},
 			NPCs:          []NPCSpec{},
 			Items:         []ItemSpec{},
 			Props:         []PropsSpec{},
@@ -513,10 +507,10 @@ func (bm *MetaPlan) GetTile(name string) raw.TileRaw {
 
 // GetPlayerStartPosition はプレイヤーの開始位置を取得する
 // ポータルへの到達性も確認し、到達可能な位置を返す
-func (bm *MetaPlan) GetPlayerStartPosition() (Coord, error) {
+func (bm *MetaPlan) GetPlayerStartPosition() (consts.Coord[int], error) {
 	// SpawnPointsが設定されていればそれを使用（テンプレートマップ用）
 	if len(bm.SpawnPoints) > 0 {
-		return Coord{X: bm.SpawnPoints[0].X, Y: bm.SpawnPoints[0].Y}, nil
+		return consts.Coord[int]{X: bm.SpawnPoints[0].X, Y: bm.SpawnPoints[0].Y}, nil
 	}
 
 	// プロシージャルマップ用: 自動的に歩行可能でポータルに到達可能な位置を探す
@@ -527,12 +521,12 @@ func (bm *MetaPlan) GetPlayerStartPosition() (Coord, error) {
 	pf := NewPathFinder(bm)
 
 	// 候補位置を試す（中央から外側へ）
-	attempts := []Coord{
-		{width / 2, height / 2},         // 中央
-		{width / 4, height / 4},         // 左上寄り
-		{3 * width / 4, height / 4},     // 右上寄り
-		{width / 4, 3 * height / 4},     // 左下寄り
-		{3 * width / 4, 3 * height / 4}, // 右下寄り
+	attempts := []consts.Coord[int]{
+		{X: width / 2, Y: height / 2},         // 中央
+		{X: width / 4, Y: height / 4},         // 左上寄り
+		{X: 3 * width / 4, Y: height / 4},     // 右上寄り
+		{X: width / 4, Y: 3 * height / 4},     // 左下寄り
+		{X: 3 * width / 4, Y: 3 * height / 4}, // 右下寄り
 	}
 
 	for _, pos := range attempts {
@@ -547,12 +541,12 @@ func (bm *MetaPlan) GetPlayerStartPosition() (Coord, error) {
 			i := resources.TileIdx(_i)
 			x, y := bm.Level.XYTileCoord(i)
 			if bm.isValidSpawnPosition(pf, int(x), int(y)) {
-				return Coord{X: int(x), Y: int(y)}, nil
+				return consts.Coord[int]{X: int(x), Y: int(y)}, nil
 			}
 		}
 	}
 
-	return Coord{}, fmt.Errorf("ポータルに到達可能な歩行可能タイルが見つかりません")
+	return consts.Coord[int]{}, fmt.Errorf("ポータルに到達可能な歩行可能タイルが見つかりません")
 }
 
 // isValidSpawnPosition は指定位置がスポーン可能かつポータルに到達可能かを判定する