LCOV - code coverage report
Current view: top level - activity - use_item.go Coverage Total Hit
Test: coverage.lcov Lines: 94.4 % 177 167
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package activity
       2              : 
       3              : import (
       4              :         "fmt"
       5              :         "slices"
       6              : 
       7              :         "github.com/kijimaD/ruins/internal/i18n"
       8              : 
       9              :         gc "github.com/kijimaD/ruins/internal/components"
      10              :         "github.com/kijimaD/ruins/internal/consts"
      11              :         "github.com/kijimaD/ruins/internal/gamelog"
      12              :         "github.com/kijimaD/ruins/internal/rawschema"
      13              :         w "github.com/kijimaD/ruins/internal/world"
      14              : 
      15              :         "github.com/kijimaD/ruins/internal/world/gameaction"
      16              :         "github.com/kijimaD/ruins/internal/world/lifecycle"
      17              :         "github.com/kijimaD/ruins/internal/world/query"
      18              :         "github.com/mlange-42/ark/ecs"
      19              : )
      20              : 
      21              : // UseItemBehavior はBehaviorの実装
      22              : type UseItemBehavior struct{}
      23              : 
      24              : // Info はBehaviorの実装
      25              : func (u *UseItemBehavior) Info() Info {
      26            1 :         return Info{
      27            1 :                 Name:            "Use Item",
      28            1 :                 Description:     "Use an item",
      29            1 :                 Interruptible:   false,
      30            1 :                 Resumable:       false,
      31            1 :                 ActionPointCost: consts.StandardActionCost,
      32            1 :                 TotalRequiredAP: 0,
      33            1 :         }
      34              : }
      35              : 
      36              : // Name はBehaviorの実装
      37              : func (u *UseItemBehavior) Name() gc.BehaviorName {
      38            1 :         return gc.BehaviorUseItem
      39            1 : }
      40              : 
      41              : // NewUseItemActivity は使用アイテムを指定してアイテム使用アクティビティを組む。
      42              : func NewUseItemActivity(target ecs.Entity) *gc.Activity {
      43            1 :         comp := NewActivity(gc.BehaviorUseItem, 0)
      44            1 :         comp.Params = &gc.UseItemParams{Target: target}
      45            1 :         return comp
      46            1 : }
      47              : 
      48              : // Validate はBehaviorの実装
      49              : func (u *UseItemBehavior) Validate(comp *gc.Activity, actor ecs.Entity, world w.World) error {
      50            1 :         p, ok := comp.Params.(*gc.UseItemParams)
      51            1 :         if !ok {
      52            1 :                 return ErrParamsTypeMismatch
      53            1 :         }
      54              : 
      55            1 :         item := p.Target
      56            1 : 
      57              :         // Use は効果のあるアイテムにしか提示されない。ここで効果なしなのは不変条件違反
      58            1 :         hasEffect := false
      59            1 :         for _, e := range useEffects {
      60            1 :                 if e.present(world, item) {
      61            1 :                         hasEffect = true
      62            1 :                         break
      63              :                 }
      64              :         }
      65            1 :         if !hasEffect {
      66            1 :                 return fmt.Errorf("item has no effect")
      67            1 :         }
      68              : 
      69            1 :         if !world.Components.HP.Has(actor) {
      70            1 :                 return fmt.Errorf("actor has no HP component")
      71            1 :         }
      72              : 
      73              :         // 各効果の使用前検証。空振りなど使えない理由があれば使う前に弾く
      74            1 :         for _, e := range useEffects {
      75            1 :                 if !e.present(world, item) {
      76            1 :                         continue
      77              :                 }
      78            1 :                 if err := e.check(u, actor, item, world); err != nil {
      79            1 :                         return err
      80            1 :                 }
      81              :         }
      82              : 
      83            1 :         return nil
      84              : }
      85              : 
      86              : // Start はBehaviorの実装
      87              : func (u *UseItemBehavior) Start(comp *gc.Activity, actor ecs.Entity, _ w.World) error {
      88            1 :         if p, ok := comp.Params.(*gc.UseItemParams); ok {
      89            1 :                 log.Debug("item use started", "actor", actor, "item", p.Target)
      90            1 :         }
      91            1 :         return nil
      92              : }
      93              : 
      94              : // DoTurn はBehaviorの実装
      95              : func (u *UseItemBehavior) DoTurn(comp *gc.Activity, actor ecs.Entity, world w.World) error {
      96            1 :         p, ok := comp.Params.(*gc.UseItemParams)
      97            1 :         if !ok {
      98            1 :                 return ErrParamsTypeMismatch
      99            1 :         }
     100              : 
     101            1 :         item := p.Target
     102            1 : 
     103              :         // アイテムが持つ効果を順に適用する。効果の一覧は useEffects が単一の真実
     104            1 :         for _, e := range useEffects {
     105            1 :                 if !e.present(world, item) {
     106            1 :                         continue
     107              :                 }
     108            1 :                 if err := e.apply(u, comp, actor, item, world); err != nil {
     109            0 :                         return err
     110            0 :                 }
     111              :         }
     112              : 
     113              :         // 消費可能アイテムの場合は削除または個数を減らす。効果を適用した後に行う
     114            1 :         if world.Components.Consumable.Has(item) {
     115            1 :                 if err := lifecycle.ChangeItemCount(world, item, -1); err != nil {
     116            0 :                         return fmt.Errorf("failed to consume item: %w", err)
     117            0 :                 }
     118              :         }
     119              : 
     120            1 :         Complete(comp)
     121            1 :         return nil
     122              : }
     123              : 
     124              : // Finish はBehaviorの実装
     125              : func (u *UseItemBehavior) Finish(_ *gc.Activity, actor ecs.Entity, _ w.World) error {
     126            1 :         log.Debug("item use finished", "actor", actor)
     127            1 :         return nil
     128            1 : }
     129              : 
     130              : // Canceled はBehaviorの実装
     131              : func (u *UseItemBehavior) Canceled(comp *gc.Activity, actor ecs.Entity, _ w.World) error {
     132            1 :         log.Debug("item use canceled", "actor", actor, "reason", comp.CancelReason)
     133            1 :         return nil
     134            1 : }
     135              : 
     136              : // applyHealing は回復処理を適用する
     137              : func (u *UseItemBehavior) applyHealing(_ *gc.Activity, actor ecs.Entity, world w.World, healing *gc.ProvidesHealing, item ecs.Entity) error {
     138              :         // 最大HPを基準に実際の回復量を計算する(絶対量指定の場合は基準値は無視される)
     139            1 :         hp := world.Components.HP.Get(actor)
     140            1 :         amount := healing.Calc(hp.Max)
     141            1 : 
     142              :         // 回復効果倍率を適用する
     143            1 :         amount = max(query.ProficiencyValue(world, actor, rawschema.ProficiencyIdHealingEffect).ApplyInt(amount), 1)
     144            1 : 
     145            1 :         actualHealing := gameaction.ApplyHealing(world, actor, amount)
     146            1 : 
     147            1 :         u.logItemUse(actor, world, item, actualHealing, true)
     148            1 : 
     149            1 :         return nil
     150            1 : }
     151              : 
     152              : // mostSevereTreatable は Treats に一致する不調を全部位から探し、最も重い1つを返す。無ければ nil。
     153              : // Validate の使用可否判定と applyRemedy の適用が同じ探索を共有する
     154              : func mostSevereTreatable(hs *gc.HealthStatus, remedy *gc.Remedy) *gc.HealthCondition {
     155            1 :         var best *gc.HealthCondition
     156            1 :         for i := range hs.Parts {
     157            1 :                 for j := range hs.Parts[i].Conditions {
     158            1 :                         c := &hs.Parts[i].Conditions[j]
     159            1 :                         if slices.Contains(remedy.Treats, c.Type) && (best == nil || c.Severity > best.Severity) {
     160            1 :                                 best = c
     161            1 :                         }
     162              :                 }
     163              :         }
     164            1 :         return best
     165              : }
     166              : 
     167              : // applyRemedy は治療を適用する。最も重い一致不調を治療済みにする。
     168              : // 治療は即座には治さず、TendQuality を立てて回復軌道へ乗せるだけ。実際の回復は ConditionSystem が進める。
     169              : // 治療した不調があれば true を返す。一致する不調が無ければ何もせず false を返す
     170              : func (u *UseItemBehavior) applyRemedy(actor ecs.Entity, world w.World, remedy *gc.Remedy, item ecs.Entity) bool {
     171            1 :         if !world.Components.HealthStatus.Has(actor) {
     172            0 :                 return false
     173            0 :         }
     174            1 :         best := mostSevereTreatable(world.Components.HealthStatus.Get(actor), remedy)
     175            1 :         if best == nil {
     176            1 :                 return false
     177            1 :         }
     178            1 :         best.TendQuality = remedy.Potency
     179            1 :         u.logRemedy(actor, world, item, best.Type)
     180            1 :         return true
     181              : }
     182              : 
     183              : // isRemedyOnly はアイテムが治療だけを効果に持つかを返す。治療専用が空振りするなら Validate で使用を弾く。
     184              : // 治療以外の効果を1つでも持てば専用でない。useEffects を見るので効果を足しても追従する
     185              : func (u *UseItemBehavior) isRemedyOnly(world w.World, item ecs.Entity) bool {
     186            1 :         if !world.Components.Remedy.Has(item) {
     187            0 :                 return false
     188            0 :         }
     189            1 :         for _, e := range useEffects {
     190            1 :                 if _, isRemedy := e.(remedyEffect); isRemedy {
     191            1 :                         continue
     192              :                 }
     193            1 :                 if e.present(world, item) {
     194            1 :                         return false
     195            1 :                 }
     196              :         }
     197            1 :         return true
     198              : }
     199              : 
     200              : // logRemedy は治療したことをログに出す。プレイヤーが使ったときだけ出す
     201              : func (u *UseItemBehavior) logRemedy(actor ecs.Entity, world w.World, item ecs.Entity, treated gc.ConditionType) {
     202            1 :         if !world.Components.Player.Has(actor) {
     203            0 :                 return
     204            0 :         }
     205            1 :         actorMarkup := query.NameMarkup(actor, query.GetEntityName(actor, world), world)
     206            1 :         itemMarkup := gamelog.Tag("item", u.getItemName(item, world))
     207            1 :         condName := query.ConditionName(world, treated)
     208            1 :         gamelog.New(query.GetGameLog(world)).
     209            1 :                 Markup(query.T(world, "%s used %s and treated %s.", actorMarkup, itemMarkup, condName)).
     210            1 :                 Log()
     211              : }
     212              : 
     213              : // applyNutrition は空腹度回復処理を適用する。鮮度に応じて栄養を調整する。
     214              : func (u *UseItemBehavior) applyNutrition(_ *gc.Activity, actor ecs.Entity, world w.World, amount int, item ecs.Entity) error {
     215            1 :         if !world.Components.Hunger.Has(actor) {
     216            1 :                 return nil
     217            1 :         }
     218            1 :         hunger := world.Components.Hunger.Get(actor)
     219            1 : 
     220              :         // Perishable を持たない食料は新鮮扱いで満額
     221            1 :         stage, ok := query.FreshnessStageOf(world, item)
     222            1 :         if !ok {
     223            1 :                 stage = rawschema.Fresh
     224            1 :         }
     225              : 
     226            1 :         freshness := world.Resources.NeedDefs.FreshnessOf(stage)
     227            1 :         nutrition := amount * freshness.NutritionPercent / 100
     228            1 :         // 鮮度で減った栄養が整数除算で0に落ちても、腐敗食は非常食として最低1は与える。
     229              :         // balance で小さい栄養値を設定したとき、劣化・腐敗が完全にゼロ効果になる罠を防ぐ
     230            1 :         if amount > 0 && nutrition < 1 {
     231            1 :                 nutrition = 1
     232            1 :         }
     233            1 :         hunger.Increase(nutrition)
     234            1 : 
     235            1 :         if freshness.IllnessChancePercent > 0 && world.Resources.Config.RNG.IntN(100) < freshness.IllnessChancePercent {
     236            1 :                 gameaction.ContractIllness(world, actor, world.Resources.ConditionDefs.ByOnset(rawschema.RottenFood))
     237            1 :         }
     238              : 
     239            1 :         hungerStage, _ := world.Resources.NeedDefs.HungerStageOf(hunger.GetLevel(world.Resources.NeedDefs))
     240            1 :         u.logNutritionUse(actor, world, item, hungerStage.ReachedLog)
     241            1 : 
     242            1 :         return nil
     243              : }
     244              : 
     245              : // logItemUse はアイテム使用のログを出力する
     246              : func (u *UseItemBehavior) logItemUse(actor ecs.Entity, world w.World, item ecs.Entity, amount int, isHealing bool) {
     247              :         // プレイヤーが関わる場合のみログ出力
     248            1 :         if !world.Components.Player.Has(actor) {
     249            1 :                 return
     250            1 :         }
     251              : 
     252            1 :         itemName := u.getItemName(item, world)
     253            1 :         actorName := query.GetEntityName(actor, world)
     254            1 : 
     255            1 :         actorMarkup := query.NameMarkup(actor, actorName, world)
     256            1 :         itemMarkup := gamelog.Tag("item", itemName)
     257            1 :         logger := gamelog.New(query.GetGameLog(world))
     258            1 :         if isHealing {
     259            1 :                 logger.Markup(query.T(world, "%s used %s and recovered %d HP.", actorMarkup, itemMarkup, amount))
     260            1 :         } else {
     261            1 :                 logger.Markup(query.T(world, "%s used %s and took %d damage.", actorMarkup, itemMarkup, amount))
     262            1 :         }
     263            1 :         logger.Log()
     264              : }
     265              : 
     266              : // logNutritionUse は空腹度回復のログを出力する。腐敗する食料は鮮度を添える。
     267              : // reachedLog は食べて達した空腹の段階のログで、空なら出さない
     268              : func (u *UseItemBehavior) logNutritionUse(actor ecs.Entity, world w.World, item ecs.Entity, reachedLog i18n.Msgid) {
     269              :         // プレイヤーが関わる場合のみログ出力
     270            1 :         if !world.Components.Player.Has(actor) {
     271            1 :                 return
     272            1 :         }
     273              : 
     274            1 :         itemName := u.getItemName(item, world)
     275            1 :         actorName := query.GetEntityName(actor, world)
     276            1 : 
     277            1 :         actorMarkup := query.NameMarkup(actor, actorName, world)
     278            1 :         itemMarkup := gamelog.Tag("item", itemName)
     279            1 :         logger := gamelog.New(query.GetGameLog(world))
     280            1 : 
     281              :         // 腐敗する食料は鮮度を名前に添える。腐敗しない食料はそのまま
     282            1 :         if stage, ok := query.FreshnessStageOf(world, item); !ok {
     283            1 :                 logger.Markup(query.T(world, "%s ate %s.", actorMarkup, itemMarkup))
     284            1 :         } else {
     285            1 :                 logger.Markup(query.T(world, world.Resources.NeedDefs.FreshnessOf(stage).EatLog, actorMarkup, itemMarkup))
     286            1 :         }
     287            1 :         logger.Log()
     288            1 : 
     289            1 :         if reachedLog != "" {
     290            1 :                 gamelog.New(query.GetGameLog(world)).Markup(query.T(world, reachedLog, actorMarkup)).Log()
     291            1 :         }
     292              : }
     293              : 
     294              : // getItemName はアイテムの名前を取得する
     295              : func (u *UseItemBehavior) getItemName(item ecs.Entity, world w.World) string {
     296            1 :         if world.Components.Name.Has(item) {
     297            1 :                 return query.T(world, world.Components.Name.Get(item).Name)
     298            1 :         }
     299            1 :         return query.T(world, "Item")
     300              : }
        

Generated by: LCOV version 2.0-1