LCOV - code coverage report
Current view: top level - activity - activity_manager.go Coverage Total Hit
Test: coverage.lcov Lines: 80.2 % 222 178
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package activity
       2              : 
       3              : import (
       4              :         "errors"
       5              :         "fmt"
       6              : 
       7              :         gc "github.com/kijimaD/ruins/internal/components"
       8              :         "github.com/kijimaD/ruins/internal/consts"
       9              :         "github.com/kijimaD/ruins/internal/gamelog"
      10              :         "github.com/kijimaD/ruins/internal/i18n"
      11              :         w "github.com/kijimaD/ruins/internal/world"
      12              : 
      13              :         "github.com/kijimaD/ruins/internal/world/query"
      14              :         "github.com/mlange-42/ark/ecs"
      15              : )
      16              : 
      17              : // ActionResult はアクション実行結果を表す
      18              : type ActionResult struct {
      19              :         Success      bool             // 実行成功/失敗
      20              :         State        gc.ActivityState // アクティビティの終了状態
      21              :         ActivityName gc.BehaviorName  // 実行されたアクティビティ名
      22              :         Message      string           // 結果メッセージ
      23              : }
      24              : 
      25              : // Execute は構築済みのアクティビティを実行する。
      26              : // 即座実行アクション(移動、攻撃等)も継続アクション(休息等)も統一的に処理する。
      27              : // comp は NewXxxActivity 構築関数で作る。
      28              : func Execute(comp *gc.Activity, actor ecs.Entity, world w.World) (*ActionResult, error) {
      29            1 :         if comp == nil {
      30            0 :                 return nil, ErrActivityNil
      31            0 :         }
      32            1 :         behaviorName := comp.BehaviorName
      33            1 :         log.Debug("action execution started",
      34            1 :                 "type", behaviorName,
      35            1 :                 "actor", actor)
      36            1 : 
      37              :         // アクティビティを開始
      38            1 :         if err := StartActivity(comp, actor, world); err != nil {
      39            1 :                 if ve, ok := errors.AsType[*UserError](err); ok {
      40              :                         // ユーザ起因の失敗はここで gamelog へ出し、err=nil で閉じる
      41            1 :                         gamelog.New(query.GetGameLog(world)).Markup(ve.Msg).Log()
      42            1 :                         result := &ActionResult{
      43            1 :                                 Success:      false,
      44            1 :                                 State:        gc.ActivityStateCanceled,
      45            1 :                                 ActivityName: behaviorName,
      46            1 :                                 Message:      ve.Msg,
      47            1 :                         }
      48            1 :                         setLastResult(actor, result, world)
      49            1 :                         return result, nil
      50            1 :                 }
      51            1 :                 result := &ActionResult{
      52            1 :                         Success:      false,
      53            1 :                         State:        gc.ActivityStateCanceled,
      54            1 :                         ActivityName: behaviorName,
      55            1 :                         Message:      err.Error(),
      56            1 :                 }
      57            1 :                 setLastResult(actor, result, world)
      58            1 :                 return result, err
      59              :         }
      60              : 
      61              :         // 全アクションを継続アクションとして扱い、常にここで1ターン進める。
      62              :         // たまたま初回ステップで完了したものが即時アクションになる。特別な即時判定は持たない。
      63              :         // 呼び出し側が同じ呼び出しで結果を必要とするため、初回で解決すれば同期的に結果を返す。
      64              :         // アクター1体だけを対象にするため、入れ子処理(攻撃→被弾側の処理など)で他エンティティが
      65              :         // 消えても影響を受けない。全エンティティを回すと処理中コンポーネントの再利用で panic しうる。
      66            1 :         if err := stepActivity(actor, world); err != nil {
      67            1 :                 return nil, err
      68            1 :         }
      69              : 
      70            1 :         currentActivity := query.GetActivity(world, actor)
      71            1 : 
      72              :         // 出口は「継続」か「初回で解決」かの2分岐。結果の中身だけが違い、
      73              :         // setLastResult と return は共通なので末尾へ1回だけ置く。
      74            1 :         var result *ActionResult
      75            1 :         if currentActivity != nil && !IsCompleted(currentActivity) && !IsCanceled(currentActivity) {
      76              :                 // 継続アクション。この初回ターン分のコストを消費し、残りは ProcessContinuousActivities が進める
      77            1 :                 query.ConsumeActionPoints(world, actor, consts.StandardActionCost)
      78            1 :                 result = &ActionResult{Success: true, State: gc.ActivityStateRunning, ActivityName: behaviorName, Message: "action started"}
      79            1 :         } else {
      80              :                 // 初回で解決した即時アクション。移動コストなど behavior 固有のコストを消費する
      81            1 :                 consumePassCost(world, actor, comp)
      82            1 :                 if currentActivity != nil && IsCanceled(currentActivity) {
      83            0 :                         result = &ActionResult{Success: false, State: gc.ActivityStateCanceled, ActivityName: behaviorName, Message: query.T(world, currentActivity.CancelReason)}
      84            0 :                 } else {
      85            1 :                         result = &ActionResult{Success: true, State: gc.ActivityStateCompleted, ActivityName: behaviorName, Message: "action completed"}
      86            1 :                 }
      87              :         }
      88            1 :         setLastResult(actor, result, world)
      89            1 :         return result, nil
      90              : }
      91              : 
      92              : // stepActivity は登録済みアクティビティを1ターン進める共通処理。
      93              : // 即時アクションの初回実行(Execute)と継続アクションの毎ターン処理
      94              : // (ProcessContinuousActivities)の両方から呼ばれ、両者で「1ターン進める」
      95              : // ロジックを一本化する。即時アクションは1ステップで完結する継続アクションの特殊ケースとして扱う。
      96              : //
      97              : // 実行する Behavior は永続化された BehaviorName から GetBehavior で引く。毎回ゼロ値の新しい
      98              : // インスタンスなので、着手時の呼び出し側インスタンスはここでは使わない。ライフサイクルを常に
      99              : // ゼロ値インスタンスで回すことで、per-アクティビティの状態は gc.Activity に置くという規律が経路によらず一貫する。
     100              : //
     101              : // DoTurn と Finish の失敗はバグなので、アクティビティを除去してエラーを返し、呼び出し側が伝播させる。
     102              : // 完了していれば Finish して直近結果を記録し除去する。
     103              : // アクター1体のみを直接処理するため、DoTurn 内の入れ子処理で他エンティティが
     104              : // 消えても走査中コンポーネントの破壊による panic を招かない。
     105              : func stepActivity(entity ecs.Entity, world w.World) error {
     106            1 :         stored := query.GetActivity(world, entity)
     107            1 :         if stored == nil {
     108            1 :                 return nil
     109            1 :         }
     110              : 
     111            1 :         behaviorName := stored.BehaviorName
     112            1 :         behavior, err := GetBehavior(behaviorName)
     113            1 :         if err != nil {
     114            1 :                 query.RemoveActivity(world, entity)
     115            1 :                 return err
     116            1 :         }
     117              : 
     118            1 :         if err := behavior.DoTurn(stored, entity, world); err != nil {
     119            1 :                 query.RemoveActivity(world, entity)
     120            1 :                 return fmt.Errorf("%s turn: %w", behaviorName, err)
     121            1 :         }
     122              : 
     123              :         // DoTurn が自ら中断したときは Canceled フックを走らせて後始末とログを行う。
     124              :         // 睡眠の起床理由の表示や Sleeping の除去はここを通る。中断理由は DoTurn が Cancel で書いている。
     125              :         // ここでは除去せず中断状態のまま残す。Execute が初回ターンの中断結果を読み取れるようにするためで、
     126              :         // 実際の除去は次巡回の ProcessContinuousActivities が担う。完了と違い中断は呼び出し側が結果を要る
     127            1 :         if IsCanceled(stored) {
     128              :                 // Canceled フックは Sleeping 除去など構造変更で stored を無効化しうる。理由は先に退避する
     129            1 :                 reason := stored.CancelReason
     130            1 :                 if err := behavior.Canceled(stored, entity, world); err != nil {
     131            0 :                         log.Warn("activity cancel processing error", "entity", entity, "type", behaviorName, "error", err.Error())
     132            0 :                 }
     133            1 :                 setLastResult(entity, &ActionResult{
     134            1 :                         Success:      false,
     135            1 :                         State:        gc.ActivityStateCanceled,
     136            1 :                         ActivityName: behaviorName,
     137            1 :                         Message:      string(reason),
     138            1 :                 }, world)
     139            1 :                 return nil
     140              :         }
     141              : 
     142            1 :         if !IsCompleted(stored) {
     143            1 :                 return nil
     144            1 :         }
     145              : 
     146            1 :         if err := behavior.Finish(stored, entity, world); err != nil {
     147            0 :                 query.RemoveActivity(world, entity)
     148            0 :                 return fmt.Errorf("%s finish: %w", behaviorName, err)
     149            0 :         }
     150            1 :         setLastResult(entity, &ActionResult{
     151            1 :                 Success:      true,
     152            1 :                 State:        gc.ActivityStateCompleted,
     153            1 :                 ActivityName: behaviorName,
     154            1 :                 Message:      "completed",
     155            1 :         }, world)
     156            1 :         query.RemoveActivity(world, entity)
     157            1 :         return nil
     158              : }
     159              : 
     160              : // setLastResult はエンティティの直近アクティビティ結果を設定する
     161              : func setLastResult(actor ecs.Entity, result *ActionResult, world w.World) {
     162            1 :         lastResult := &gc.LastActivity{
     163            1 :                 BehaviorName: result.ActivityName,
     164            1 :                 State:        result.State,
     165            1 :                 Success:      result.Success,
     166            1 :                 Message:      result.Message,
     167            1 :         }
     168              : 
     169            1 :         if err := gc.Upsert(world.ECS, world.Components.LastActivity, actor, lastResult); err != nil {
     170            0 :                 log.Warn("failed to record last activity result", "actor", actor, "error", err.Error())
     171            0 :         }
     172              : }
     173              : 
     174              : // GetLastResult はエンティティの直近アクティビティ結果を取得する
     175              : func GetLastResult(actor ecs.Entity, world w.World) *gc.LastActivity {
     176            1 :         if !world.Components.LastActivity.Has(actor) {
     177            1 :                 return nil
     178            1 :         }
     179            1 :         return world.Components.LastActivity.Get(actor)
     180              : }
     181              : 
     182              : // StartActivity は新しいアクティビティを開始する。検証か開始に失敗すれば error を返す
     183              : func StartActivity(comp *gc.Activity, actor ecs.Entity, world w.World) error {
     184            1 :         if comp == nil {
     185            0 :                 return ErrActivityNil
     186            0 :         }
     187              : 
     188            1 :         behavior, err := GetBehavior(comp.BehaviorName)
     189            1 :         if err != nil {
     190            0 :                 return err
     191            0 :         }
     192              : 
     193              :         // 既存のアクティビティがある場合は中断
     194            1 :         if currentActivity := query.GetActivity(world, actor); currentActivity != nil {
     195            1 :                 if err := InterruptActivity(actor, "starting a new activity", world); err != nil {
     196            0 :                         log.Warn("failed to interrupt existing activity", "entity", actor, "error", err.Error())
     197            0 :                 }
     198              :         }
     199              : 
     200            1 :         if err := behavior.Validate(comp, actor, world); err != nil {
     201            1 :                 return err
     202            1 :         }
     203              : 
     204              :         // アクティビティをコンポーネントとして登録する
     205            1 :         if err := query.SetActivity(world, actor, comp); err != nil {
     206            0 :                 return fmt.Errorf("failed to register activity: %w", err)
     207            0 :         }
     208            1 :         stored := query.GetActivity(world, actor)
     209            1 :         stored.State = gc.ActivityStateRunning
     210            1 : 
     211              :         // BehaviorのStart処理を実行
     212            1 :         if err := behavior.Start(stored, actor, world); err != nil {
     213              :                 // 開始に失敗した場合はクリーンアップ
     214            0 :                 query.RemoveActivity(world, actor)
     215            0 :                 return fmt.Errorf("failed to start activity: %w", err)
     216            0 :         }
     217              : 
     218            1 :         log.Debug("activity started",
     219            1 :                 "entity", actor,
     220            1 :                 "type", behavior.Name(),
     221            1 :                 "required", stored.Progress.Max)
     222            1 : 
     223            1 :         return nil
     224              : }
     225              : 
     226              : // InterruptActivity は指定されたエンティティのアクティビティを中断する
     227              : func InterruptActivity(entity ecs.Entity, reason i18n.Msgid, world w.World) error {
     228            1 :         comp := query.GetActivity(world, entity)
     229            1 :         if comp == nil {
     230            1 :                 return ErrActivityNotFound
     231            1 :         }
     232              : 
     233            1 :         return Interrupt(comp, reason)
     234              : }
     235              : 
     236              : // ResumeActivity は指定されたエンティティのアクティビティを再開する
     237              : func ResumeActivity(entity ecs.Entity, world w.World) error {
     238            1 :         comp := query.GetActivity(world, entity)
     239            1 :         if comp == nil {
     240            1 :                 return ErrActivityNotFound
     241            1 :         }
     242              : 
     243            1 :         if !CanResume(comp) {
     244            0 :                 return fmt.Errorf("activity '%s' cannot be resumed", GetDisplayName(comp))
     245            0 :         }
     246              : 
     247            1 :         return Resume(comp)
     248              : }
     249              : 
     250              : // CancelActivity は指定されたエンティティのアクティビティをキャンセルする
     251              : func CancelActivity(entity ecs.Entity, reason i18n.Msgid, world w.World) {
     252            1 :         comp := query.GetActivity(world, entity)
     253            1 :         if comp == nil {
     254            1 :                 return
     255            1 :         }
     256              : 
     257              :         // Canceled フックは Sleeping 除去など構造変更で comp を無効化しうる。フック後に使う値は先に退避する
     258            1 :         behaviorName := comp.BehaviorName
     259            1 :         behavior, err := GetBehavior(behaviorName)
     260            1 :         if err != nil {
     261            0 :                 log.Warn("failed to get behavior", "entity", entity, "error", err.Error())
     262            0 :                 query.RemoveActivity(world, entity)
     263            0 :                 return
     264            0 :         }
     265              : 
     266              :         // 先に中断状態と理由を書く。Canceled フックは comp.CancelReason を読んでログに出すため、
     267              :         // フックより前に理由を確定させる。順序を逆にすると理由が空のまま表示される
     268            1 :         Cancel(comp, reason)
     269            1 : 
     270              :         // BehaviorのCanceled処理を実行
     271            1 :         if err := behavior.Canceled(comp, entity, world); err != nil {
     272            0 :                 log.Warn("activity cancel processing error",
     273            0 :                         "entity", entity,
     274            0 :                         "error", err.Error())
     275            0 :         }
     276              : 
     277              :         // 結果を記録
     278            1 :         result := &ActionResult{
     279            1 :                 Success:      false,
     280            1 :                 State:        gc.ActivityStateCanceled,
     281            1 :                 ActivityName: behaviorName,
     282            1 :                 Message:      string(reason),
     283            1 :         }
     284            1 :         setLastResult(entity, result, world)
     285            1 : 
     286            1 :         query.RemoveActivity(world, entity)
     287            1 : 
     288            1 :         log.Debug("activity canceled",
     289            1 :                 "entity", entity,
     290            1 :                 "type", behaviorName,
     291            1 :                 "reason", reason)
     292              : }
     293              : 
     294              : // ProcessContinuousActivities は継続中の全アクティビティを1ターン分進める。
     295              : // 即時アクション(Required==0)は Execute がその場で完結させるため、ここに残るのは継続実行アクションのみ。
     296              : // 走査中に他エンティティのアクティビティが削除されても、各要素で生存確認するため安全。
     297              : func ProcessContinuousActivities(world w.World) error {
     298            1 :         var entities []ecs.Entity
     299            1 :         // 退避中ステージのエンティティのアクティビティは進めない
     300            1 :         activityQuery := query.ActiveFilter1[gc.Activity](world).Query()
     301            1 :         for activityQuery.Next() {
     302            1 :                 entities = append(entities, activityQuery.Entity())
     303            1 :         }
     304              : 
     305            1 :         for _, entity := range entities {
     306            1 :                 if !world.ECS.Alive(entity) || !world.Components.Activity.Has(entity) {
     307            0 :                         continue
     308              :                 }
     309            1 :                 comp := world.Components.Activity.Get(entity)
     310            1 : 
     311            1 :                 if !IsActive(comp) {
     312            0 :                         if IsCompleted(comp) || IsCanceled(comp) {
     313            0 :                                 query.RemoveActivity(world, entity)
     314            0 :                         }
     315            0 :                         continue
     316              :                 }
     317              : 
     318            1 :                 if err := stepActivity(entity, world); err != nil {
     319            0 :                         return err
     320            0 :                 }
     321              :         }
     322            1 :         return nil
     323              : }
     324              : 
     325              : // consumePassCost はアクションのAPコストを消費する。
     326              : // Behavior は comp.BehaviorName から GetBehavior で引く。
     327              : func consumePassCost(world w.World, actor ecs.Entity, comp *gc.Activity) {
     328            1 :         behavior, err := GetBehavior(comp.BehaviorName)
     329            1 :         if err != nil {
     330            0 :                 log.Error("failed to get behavior", "actor", actor, "error", err.Error())
     331            0 :                 return
     332            0 :         }
     333            1 :         cost := behavior.Info().ActionPointCost
     334            1 : 
     335              :         // 移動行動の場合、移動先タイルのPassCostを加算する。MoveParams を持つのは移動だけ
     336            1 :         if mp, ok := comp.Params.(*gc.MoveParams); ok {
     337            1 :                 cost += getPassCostAt(world, int(mp.Destination.X), int(mp.Destination.Y))
     338            1 :         }
     339              : 
     340            1 :         if !query.ConsumeActionPoints(world, actor, cost) {
     341            0 :                 log.Debug("no TurnBased component", "actor", actor)
     342            0 :         }
     343              : }
     344              : 
     345              : // getPassCostAt は指定座標にある固定物のPassCostを合算して返す
     346              : func getPassCostAt(world w.World, x, y int) int {
     347            1 :         total := 0
     348            1 :         passCostQuery := query.ActiveFilter2[gc.GridElement, gc.PassCost](world).Query()
     349            1 :         for passCostQuery.Next() {
     350            1 :                 entity := passCostQuery.Entity()
     351            1 :                 grid := world.Components.GridElement.Get(entity)
     352            1 :                 if int(grid.X) == x && int(grid.Y) == y {
     353            1 :                         mc := world.Components.PassCost.Get(entity)
     354            1 :                         total += mc.Value
     355            1 :                 }
     356              :         }
     357            1 :         return total
     358              : }
     359              : 
     360              : // errNoTurnBased はエンティティがTurnBasedを持たないときに返す
     361              : var errNoTurnBased = errors.New("TurnBased component not found")
     362              : 
     363              : // getEntityMaxAP はエンティティの最大AP値を取得する
     364              : func getEntityMaxAP(entity ecs.Entity, world w.World) (int, error) {
     365            1 :         if !world.Components.TurnBased.Has(entity) {
     366            1 :                 return 0, fmt.Errorf("%w: entity=%v", errNoTurnBased, entity)
     367            1 :         }
     368            1 :         return world.Components.TurnBased.Get(entity).AP.Max, nil
     369              : }
        

Generated by: LCOV version 2.0-1