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 : }
|