LCOV - code coverage report
Current view: top level - components - invariant.go Coverage Total Hit
Test: coverage.lcov Lines: 100.0 % 55 55
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package components
       2              : 
       3              : import (
       4              :         "reflect"
       5              :         "strings"
       6              : 
       7              :         "github.com/mlange-42/ark/ecs"
       8              : )
       9              : 
      10              : // hasser はエンティティが特定コンポーネントを持つか判定できる型。
      11              : // Ark の *ecs.Map[T] はいずれも Has(ecs.Entity) bool を満たす
      12              : type hasser interface {
      13              :         Has(ecs.Entity) bool
      14              : }
      15              : 
      16              : // Pred はエンティティに対する述語を表すインターフェース。
      17              : // Has, And, Or, Not を組み合わせてコンポーネント間の関係を宣言的に記述する
      18              : type Pred interface {
      19              :         Eval(entity ecs.Entity) bool
      20              :         String() string
      21              : }
      22              : 
      23              : // Has は指定コンポーネントの存在を検査する述語
      24              : type Has struct {
      25              :         Label string
      26              :         Comp  hasser
      27              : }
      28              : 
      29              : // Eval はPredインターフェースを実装する
      30              : func (h Has) Eval(entity ecs.Entity) bool {
      31            1 :         return h.Comp.Has(entity)
      32            1 : }
      33              : 
      34              : func (h Has) String() string {
      35            1 :         return h.Label
      36            1 : }
      37              : 
      38              : // And はすべての条件を満たすことを要求する述語
      39              : type And []Pred
      40              : 
      41              : // Eval はPredインターフェースを実装する
      42              : func (a And) Eval(entity ecs.Entity) bool {
      43            1 :         for _, p := range a {
      44            1 :                 if !p.Eval(entity) {
      45            1 :                         return false
      46            1 :                 }
      47              :         }
      48            1 :         return true
      49              : }
      50              : 
      51              : func (a And) String() string {
      52            1 :         parts := make([]string, len(a))
      53            1 :         for i, p := range a {
      54            1 :                 parts[i] = p.String()
      55            1 :         }
      56            1 :         return "(" + strings.Join(parts, " AND ") + ")"
      57              : }
      58              : 
      59              : // Or はいずれかの条件を満たすことを要求する述語
      60              : type Or []Pred
      61              : 
      62              : // Eval はPredインターフェースを実装する
      63              : func (o Or) Eval(entity ecs.Entity) bool {
      64            1 :         for _, p := range o {
      65            1 :                 if p.Eval(entity) {
      66            1 :                         return true
      67            1 :                 }
      68              :         }
      69            1 :         return false
      70              : }
      71              : 
      72              : func (o Or) String() string {
      73            1 :         parts := make([]string, len(o))
      74            1 :         for i, p := range o {
      75            1 :                 parts[i] = p.String()
      76            1 :         }
      77            1 :         return "(" + strings.Join(parts, " OR ") + ")"
      78              : }
      79              : 
      80              : // Not は条件の否定を表す述語
      81              : type Not struct {
      82              :         Pred Pred
      83              : }
      84              : 
      85              : // Eval はPredインターフェースを実装する
      86              : func (n Not) Eval(entity ecs.Entity) bool {
      87            1 :         return !n.Pred.Eval(entity)
      88            1 : }
      89              : 
      90              : func (n Not) String() string {
      91            1 :         return "NOT " + n.Pred.String()
      92            1 : }
      93              : 
      94              : // Category はコンポーネントの組み合わせでエンティティのカテゴリを定義する。
      95              : // Pred を実装しているので、他の述語と同様に組み合わせて使える
      96              : type Category struct {
      97              :         Name string
      98              :         Pred Pred
      99              : }
     100              : 
     101              : // Eval はPredインターフェースを実装する
     102              : func (cat Category) Eval(entity ecs.Entity) bool {
     103            1 :         return cat.Pred.Eval(entity)
     104            1 : }
     105              : 
     106              : func (cat Category) String() string {
     107            1 :         return cat.Name
     108            1 : }
     109              : 
     110              : // CategoryGroupKey はカテゴリグループを識別するキー
     111              : type CategoryGroupKey string
     112              : 
     113              : const (
     114              :         // FieldLookCategoryKey はフィールド上の観察で表示する分類
     115              :         FieldLookCategoryKey CategoryGroupKey = "field_look"
     116              : )
     117              : 
     118              : // フィールド観察カテゴリ名の定数。値は query.T の msgid として使う
     119              : const (
     120              :         CategoryPlayer = "Self"
     121              :         CategoryEnemy  = "Enemy"
     122              :         CategoryNPC    = "NPC"
     123              :         CategoryItem   = "Item"
     124              :         CategoryProp   = "Prop"
     125              :         CategoryTile   = "Tile"
     126              : )
     127              : 
     128              : // has は Components のフィールド名を自動解決して Has を生成する。
     129              : // Map ハンドルのポインタ同一性でフィールドを特定する
     130              : func (c *Components) has(comp hasser) Has {
     131            1 :         val := reflect.ValueOf(c).Elem()
     132            1 :         typ := val.Type()
     133            1 :         for i := range val.NumField() {
     134            1 :                 if val.Field(i).Interface() == comp {
     135            1 :                         return Has{Label: typ.Field(i).Name, Comp: comp}
     136            1 :                 }
     137              :         }
     138            1 :         panic("component not found in Components")
     139              : }
     140              : 
     141              : // Categories は観点ごとにグループ化されたカテゴリ定義を返す
     142              : func (c *Components) Categories() map[CategoryGroupKey][]Category {
     143            1 :         return map[CategoryGroupKey][]Category{
     144            1 :                 FieldLookCategoryKey: {
     145            1 :                         // Player を先に判定する。Player は FactionAlly も持つため
     146            1 :                         {Name: CategoryPlayer, Pred: c.has(c.Player)},
     147            1 :                         {Name: CategoryEnemy, Pred: c.has(c.FactionEnemy)},
     148            1 :                         {Name: CategoryNPC, Pred: Or{c.has(c.FactionAlly), c.has(c.FactionNeutral)}},
     149            1 :                         {Name: CategoryItem, Pred: c.has(c.Item)},
     150            1 :                         {Name: CategoryProp, Pred: c.has(c.Prop)},
     151            1 :                         {Name: CategoryTile, Pred: c.has(c.Tile)},
     152            1 :                 },
     153            1 :         }
     154              : }
     155              : 
     156              : // CategoryOf は指定グループ内でエンティティが属するカテゴリ名を返す。
     157              : // どのカテゴリにも属さない場合は空文字とfalseを返す
     158              : func (c *Components) CategoryOf(key CategoryGroupKey, entity ecs.Entity) (string, bool) {
     159            1 :         for _, cat := range c.Categories()[key] {
     160            1 :                 if cat.Eval(entity) {
     161            1 :                         return cat.Name, true
     162            1 :                 }
     163              :         }
     164            1 :         return "", false
     165              : }
        

Generated by: LCOV version 2.0-1