LCOV - code coverage report
Current view: top level - world/lifecycle - inventory.go Coverage Total Hit
Test: coverage.lcov Lines: 83.6 % 61 51
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package lifecycle
       2              : 
       3              : import (
       4              :         "errors"
       5              :         "fmt"
       6              : 
       7              :         gc "github.com/kijimaD/ruins/internal/components"
       8              :         w "github.com/kijimaD/ruins/internal/world"
       9              :         "github.com/kijimaD/ruins/internal/world/query"
      10              :         "github.com/mlange-42/ark/ecs"
      11              : )
      12              : 
      13              : var (
      14              :         // errZeroCountChange は個数の変化量が0のときに返す
      15              :         errZeroCountChange = errors.New("count change must not be zero")
      16              :         // errInsufficientItemCount は所持数を超えて減らそうとしたときに返す
      17              :         errInsufficientItemCount = errors.New("insufficient item count")
      18              :         // errNoStackLocation はバックパックにも収納にもないアイテムを増やそうとしたときに返す
      19              :         errNoStackLocation = errors.New("cannot add to stack: entity has no backpack or storage location")
      20              :         // errStackNotFound は未所持のスタックアイテムを減らそうとしたときに返す
      21              :         errStackNotFound = errors.New("stackable item not found")
      22              : )
      23              : 
      24              : // ChangeItemCount は entity が属するスタックの個数を delta だけ増減する。
      25              : // 個数は保存しないので、増加は同種を delta 個生成し、減少は同一スタックのエンティティを
      26              : // |delta| 個取り除く。1個1エンティティのため、これがスタック数の変更になる。
      27              : func ChangeItemCount(world w.World, entity ecs.Entity, delta int) error {
      28            1 :         if delta == 0 {
      29            1 :                 return errZeroCountChange
      30            1 :         }
      31              : 
      32            1 :         if delta > 0 {
      33            1 :                 if err := addToStack(world, entity, delta); err != nil {
      34            1 :                         return err
      35            1 :                 }
      36              :         } else {
      37            1 :                 if err := removeFromStack(world, entity, -delta); err != nil {
      38            1 :                         return err
      39            1 :                 }
      40              :         }
      41              : 
      42              :         // インベントリ変動フラグを立てる。反復中の構造変更を避けるため、
      43              :         // プレイヤーを一旦集めてからマーカーを付ける。
      44            1 :         var players []ecs.Entity
      45            1 :         playerQuery := ecs.NewFilter1[gc.Player](world.ECS).Query()
      46            1 :         for playerQuery.Next() {
      47            1 :                 players = append(players, playerQuery.Entity())
      48            1 :         }
      49            1 :         for _, playerEntity := range players {
      50            1 :                 ensureMarker(world, world.Components.WeightDirty, playerEntity, &gc.WeightDirty{})
      51            1 :         }
      52              : 
      53            1 :         return nil
      54              : }
      55              : 
      56              : // removeFromStack は entity と同一スタックのエンティティを n 個取り除く。在庫が足りなければエラー。
      57              : func removeFromStack(world w.World, entity ecs.Entity, n int) error {
      58            1 :         members := query.StackMembers(world, entity)
      59            1 :         if n > len(members) {
      60            1 :                 return fmt.Errorf("%w: have=%d, remove=%d", errInsufficientItemCount, len(members), n)
      61            1 :         }
      62            1 :         for i := range n {
      63            1 :                 world.ECS.RemoveEntity(members[i])
      64            1 :         }
      65            1 :         return nil
      66              : }
      67              : 
      68              : // addToStack は entity と同じ位置へ同種のアイテムを n 個生成する。腐敗品は生成直後の鮮度になる。
      69              : func addToStack(world w.World, entity ecs.Entity, n int) error {
      70            1 :         id := world.Components.RawID.Get(entity).ID
      71            1 :         switch {
      72              :         case world.Components.LocationInBackpack.Has(entity):
      73            1 :                 owner := world.Components.LocationInBackpack.Get(entity).Owner
      74            1 :                 for range n {
      75            1 :                         e, err := spawnItemBase(world, id)
      76            1 :                         if err != nil {
      77            0 :                                 return err
      78            0 :                         }
      79            1 :                         if err := MoveToBackpack(world, e, owner); err != nil {
      80            0 :                                 return err
      81            0 :                         }
      82              :                 }
      83              :         case world.Components.LocationInStorage.Has(entity):
      84            1 :                 owner := world.Components.LocationInStorage.Get(entity).Owner
      85            1 :                 for range n {
      86            1 :                         e, err := spawnItemBase(world, id)
      87            1 :                         if err != nil {
      88            0 :                                 return err
      89            0 :                         }
      90            1 :                         if err := MoveToStorage(world, e, owner); err != nil {
      91            0 :                                 return err
      92            0 :                         }
      93              :                 }
      94              :         default:
      95            1 :                 return errNoStackLocation
      96              :         }
      97            1 :         return nil
      98              : }
      99              : 
     100              : // ChangeStackCount は指定した名前のスタックアイテムの数量を変更する。
     101              : // amount が正の場合は増加、負の場合は減少する
     102              : func ChangeStackCount(world w.World, name string, amount int) error {
     103            1 :         if amount == 0 {
     104            0 :                 return errZeroCountChange
     105            0 :         }
     106              : 
     107            1 :         entity, found := query.FindStackInInventory(world, name)
     108            1 :         if found {
     109            1 :                 return ChangeItemCount(world, entity, amount)
     110            1 :         }
     111              : 
     112            1 :         if amount < 0 {
     113            1 :                 return fmt.Errorf("%w: %s", errStackNotFound, name)
     114            1 :         }
     115              : 
     116            1 :         _, err := SpawnBackpackItem(world, name, amount)
     117            1 :         return err
     118              : }
        

Generated by: LCOV version 2.0-1