LCOV - code coverage report
Current view: top level - raw - raw.go Coverage Total Hit
Test: coverage.lcov Lines: 97.6 % 834 814
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package raw
       2              : 
       3              : import (
       4              :         "errors"
       5              :         "fmt"
       6              :         "image/color"
       7              :         "math/rand/v2"
       8              : 
       9              :         "github.com/kijimaD/ruins/internal/i18n"
      10              : 
      11              :         "github.com/BurntSushi/toml"
      12              :         "github.com/kijimaD/ruins/assets"
      13              :         gc "github.com/kijimaD/ruins/internal/components"
      14              :         "github.com/kijimaD/ruins/internal/consts"
      15              :         "github.com/kijimaD/ruins/internal/rawschema"
      16              : )
      17              : 
      18              : // PtrSlice はrawschema.Rawsの*[]Tフィールドを安全にデリファレンスする
      19              : // nilポインタの場合はnilスライスを返す
      20              : func PtrSlice[T any](p *[]T) []T {
      21            1 :         if p == nil {
      22            1 :                 return nil
      23            1 :         }
      24            1 :         return *p
      25              : }
      26              : 
      27              : // deref はポインタの指す値を返す。nil ならゼロ値を返す
      28              : func deref[T any](p *T) T {
      29            1 :         if p == nil {
      30            1 :                 var zero T
      31            1 :                 return zero
      32            1 :         }
      33            1 :         return *p
      34              : }
      35              : 
      36              : // FindByKey はスライスからキー関数でマッチする要素を線形検索する
      37              : func FindByKey[T any](slice *[]T, keyFn func(T) string, target string) (T, bool) {
      38            1 :         for _, item := range PtrSlice(slice) {
      39            1 :                 if keyFn(item) == target {
      40            1 :                         return item, true
      41            1 :                 }
      42              :         }
      43            1 :         var zero T
      44            1 :         return zero, false
      45              : }
      46              : 
      47              : // LoadFromFile はファイルからローデータを読み込み、Go で書いた決まりを検証する。
      48              : func LoadFromFile(path string) (rawschema.Raws, error) {
      49            1 :         bs, err := assets.FS.ReadFile(path)
      50            1 :         if err != nil {
      51            1 :                 return rawschema.Raws{}, err
      52            1 :         }
      53            1 :         raws, err := DecodeRaws(string(bs))
      54            1 :         if err != nil {
      55            0 :                 return rawschema.Raws{}, err
      56            0 :         }
      57            1 :         if err := validateRules(raws); err != nil {
      58            0 :                 return rawschema.Raws{}, fmt.Errorf("failed to validate raw data for %s: %w", path, err)
      59            0 :         }
      60            1 :         if err := validateCodeRows(raws); err != nil {
      61            0 :                 return rawschema.Raws{}, fmt.Errorf("failed to validate raw data for %s: %w", path, err)
      62            0 :         }
      63            1 :         return raws, nil
      64              : }
      65              : 
      66              : var (
      67              :         // errTOMLDecode はTOMLの構文が壊れていてデコードできないときに返す
      68              :         errTOMLDecode = errors.New("TOML decode error")
      69              :         // errUnknownTOMLKeys はTOMLにスキーマにないキーが含まれるときに返す
      70              :         errUnknownTOMLKeys = errors.New("unknown keys found in TOML")
      71              :         // errBookSkillMissing は本にスキルが指定されていないときに返す
      72              :         errBookSkillMissing = errors.New("book requires a Skill")
      73              :         // errBlockPassWithPassCost は通行不可の prop に移動コストが指定されているときに返す
      74              :         errBlockPassWithPassCost = errors.New("blockPass and passCost cannot both be set; passCost is unnecessary when impassable")
      75              : )
      76              : 
      77              : // DecodeRaws はTOML文字列をrawschema.Raws構造体にデコードする
      78              : // 未知のキーが含まれる場合はエラーを返す
      79              : func DecodeRaws(content string) (rawschema.Raws, error) {
      80            1 :         var raws rawschema.Raws
      81            1 :         metaData, err := toml.Decode(content, &raws)
      82            1 :         if err != nil {
      83            1 :                 return rawschema.Raws{}, fmt.Errorf("%w: %w", errTOMLDecode, err)
      84            1 :         }
      85            1 :         if undecoded := metaData.Undecoded(); len(undecoded) > 0 {
      86            1 :                 return rawschema.Raws{}, fmt.Errorf("%w: %v", errUnknownTOMLKeys, undecoded)
      87            1 :         }
      88            1 :         return raws, nil
      89              : }
      90              : 
      91              : // FindItem は指定された名前のアイテム定義を検索する
      92              : func FindItem(raws rawschema.Raws, name string) (rawschema.Item, error) {
      93            2 :         item, ok := FindByKey(raws.Items, func(i rawschema.Item) string { return i.Id }, name)
      94            1 :         if !ok {
      95            1 :                 return rawschema.Item{}, NewKeyNotFoundError(name, "Items")
      96            1 :         }
      97            1 :         return item, nil
      98              : }
      99              : 
     100              : // ItemName は id からアイテムの表示名を返す。定義が見つからなければ id をそのまま返す
     101              : func ItemName(raws rawschema.Raws, id string) i18n.Msgid {
     102            1 :         item, err := FindItem(raws, id)
     103            1 :         if err != nil {
     104            1 :                 return i18n.Msgid(id)
     105            1 :         }
     106            1 :         return i18n.Msgid(item.Name)
     107              : }
     108              : 
     109              : // FindMember は指定された名前のメンバー定義を検索する
     110              : func FindMember(raws rawschema.Raws, name string) (rawschema.Member, error) {
     111            2 :         member, ok := FindByKey(raws.Members, func(m rawschema.Member) string { return m.Id }, name)
     112            1 :         if !ok {
     113            1 :                 return rawschema.Member{}, NewKeyNotFoundError(name, "Members")
     114            1 :         }
     115            1 :         return member, nil
     116              : }
     117              : 
     118              : // FindSpriteSheet は指定された名前のスプライトシートを検索する
     119              : func FindSpriteSheet(raws rawschema.Raws, name string) (rawschema.SpriteSheet, error) {
     120            2 :         sheet, ok := FindByKey(raws.SpriteSheets, func(s rawschema.SpriteSheet) string { return s.Name }, name)
     121            1 :         if !ok {
     122            1 :                 return rawschema.SpriteSheet{}, NewKeyNotFoundError(name, "SpriteSheets")
     123            1 :         }
     124            1 :         return sheet, nil
     125              : }
     126              : 
     127              : // toGCSpriteRender はrawschema.SpriteRenderからgc.SpriteRenderに変換する
     128              : func toGCSpriteRender(s rawschema.SpriteRender) gc.SpriteRender {
     129            1 :         return gc.SpriteRender{
     130            1 :                 SpriteSheetName: s.SpriteSheetName,
     131            1 :                 SpriteKey:       s.SpriteKey,
     132            1 :                 Depth:           gc.DepthNum(int(s.Depth)),
     133            1 :                 Shape:           deref(s.Shape),
     134            1 :         }
     135              : }
     136              : 
     137              : // toGCLightSource はrawschema.LightSourceからgc.LightSourceに変換する
     138              : func toGCLightSource(ls *rawschema.LightSource) *gc.LightSource {
     139            1 :         if ls == nil {
     140            1 :                 return nil
     141            1 :         }
     142            1 :         return &gc.LightSource{
     143            1 :                 Radius:  consts.Tile(ls.Radius),
     144            1 :                 Enabled: ls.Enabled,
     145            1 :                 Color: color.RGBA{
     146            1 :                         R: ls.Color.R,
     147            1 :                         G: ls.Color.G,
     148            1 :                         B: ls.Color.B,
     149            1 :                         A: ls.Color.A,
     150            1 :                 },
     151            1 :         }
     152              : }
     153              : 
     154              : // toGCHeatSource はrawschema.HeatSourceからgc.HeatSourceに変換する
     155              : func toGCHeatSource(hs *rawschema.HeatSource) *gc.HeatSource {
     156            1 :         if hs == nil {
     157            1 :                 return nil
     158            1 :         }
     159            1 :         return &gc.HeatSource{
     160            1 :                 Radius: consts.Tile(hs.Radius),
     161            1 :                 Warmth: hs.Warmth,
     162            1 :         }
     163              : }
     164              : 
     165              : // toGCBedding はrawschema.Beddingからgc.Beddingに変換する
     166              : func toGCBedding(b *rawschema.Bedding) *gc.Bedding {
     167            1 :         if b == nil {
     168            1 :                 return nil
     169            1 :         }
     170            1 :         return &gc.Bedding{
     171            1 :                 Quality: consts.Percent(b.Quality),
     172            1 :         }
     173              : }
     174              : 
     175              : // parseTargetType はTargetGroup/TargetNumの文字列ペアをパースする
     176              : func parseTargetType(targetGroup rawschema.TargetGroup, targetNum rawschema.TargetNum) gc.TargetType {
     177            1 :         if targetGroup == "" {
     178            1 :                 return gc.TargetType{}
     179            1 :         }
     180            1 :         return gc.TargetType{
     181            1 :                 TargetGroup: targetGroup,
     182            1 :                 TargetNum:   targetNum,
     183            1 :         }
     184              : }
     185              : 
     186              : // parseMelee はrawschema.Meleeからgc.Meleeを生成する
     187              : func parseMelee(m *rawschema.Melee) *gc.Melee {
     188            1 :         return &gc.Melee{
     189            1 :                 Accuracy:       m.Accuracy,
     190            1 :                 Damage:         m.Damage,
     191            1 :                 AttackCount:    m.AttackCount,
     192            1 :                 Element:        m.Element,
     193            1 :                 AttackCategory: m.AttackCategory,
     194            1 :                 Cost:           m.Cost,
     195            1 :                 TargetType:     parseTargetType(m.TargetGroup, m.TargetNum),
     196            1 :         }
     197              : }
     198              : 
     199              : // parseFire はrawschema.Fireからgc.Fireを生成する
     200              : func parseFire(f *rawschema.Fire) *gc.Fire {
     201            1 :         var ammoTag rawschema.AmmoTag
     202            1 :         if f.AmmoTag != nil {
     203            1 :                 ammoTag = *f.AmmoTag
     204            1 :         }
     205            1 :         return &gc.Fire{
     206            1 :                 Accuracy:       f.Accuracy,
     207            1 :                 Damage:         f.Damage,
     208            1 :                 AttackCount:    f.AttackCount,
     209            1 :                 Element:        f.Element,
     210            1 :                 AttackCategory: f.AttackCategory,
     211            1 :                 Cost:           f.Cost,
     212            1 :                 TargetType:     parseTargetType(f.TargetGroup, f.TargetNum),
     213            1 :                 Magazine:       f.MagazineSize,
     214            1 :                 MagazineSize:   f.MagazineSize,
     215            1 :                 ReloadEffort:   f.ReloadEffort,
     216            1 :                 AmmoTag:        ammoTag,
     217            1 :         }
     218              : }
     219              : 
     220              : // newProvidesHealingFromAPI はrawschema.ProvidesHealingからProvidesHealingコンポーネントを生成する
     221              : func newProvidesHealingFromAPI(h *rawschema.ProvidesHealing) *gc.ProvidesHealing {
     222            1 :         switch h.ValueType {
     223              :         case rawschema.PERCENTAGE:
     224            1 :                 return &gc.ProvidesHealing{Kind: gc.HealRatio, Amount: h.Ratio}
     225              :         default:
     226            1 :                 return &gc.ProvidesHealing{Kind: gc.HealNumeral, Amount: float64(h.Amount)}
     227              :         }
     228              : }
     229              : 
     230              : // newBookFromAPI はrawschema.Bookからgc.Bookを生成する
     231              : func newBookFromAPI(b *rawschema.Book) (*gc.Book, error) {
     232            1 :         if b.Skill == nil {
     233            1 :                 return nil, errBookSkillMissing
     234            1 :         }
     235              : 
     236            1 :         skillID := b.Skill.TargetSkill
     237            1 : 
     238            1 :         return &gc.Book{
     239            1 :                 Effort: gc.IntPool{Max: b.TotalEffort},
     240            1 :                 Skill: &gc.SkillBookEffect{
     241            1 :                         TargetSkill:   skillID,
     242            1 :                         MaxLevel:      b.Skill.MaxLevel,
     243            1 :                         RequiredLevel: b.Skill.RequiredLevel,
     244            1 :                 },
     245            1 :         }, nil
     246              : }
     247              : 
     248              : // NewItemSpec は指定された名前のアイテムのEntitySpecを生成する
     249              : func NewItemSpec(raws rawschema.Raws, name string) (gc.EntitySpec, error) {
     250            1 :         item, err := FindItem(raws, name)
     251            1 :         if err != nil {
     252            1 :                 return gc.EntitySpec{}, err
     253            1 :         }
     254              : 
     255            1 :         entitySpec := gc.EntitySpec{}
     256            1 :         entitySpec.Item = &gc.Item{}
     257            1 :         entitySpec.Name = &gc.Name{Name: i18n.Msgid(item.Name)}
     258            1 :         entitySpec.RawID = &gc.RawID{ID: item.Id}
     259            1 :         entitySpec.Description = &gc.Description{Description: i18n.Msgid(item.Description)}
     260            1 : 
     261              :         // デフォルト値設定
     262            1 :         spriteSheetName := item.SpriteSheetName
     263            1 :         spriteKey := item.SpriteKey
     264            1 :         if spriteSheetName == "" {
     265            1 :                 spriteSheetName = "field"
     266            1 :         }
     267            1 :         if spriteKey == "" {
     268            1 :                 spriteKey = "field_item"
     269            1 :         }
     270              : 
     271            1 :         entitySpec.SpriteRender = &gc.SpriteRender{
     272            1 :                 SpriteSheetName: spriteSheetName,
     273            1 :                 SpriteKey:       spriteKey,
     274            1 :                 AnimKeys:        PtrSlice(item.AnimKeys),
     275            1 :                 Depth:           gc.DepthNumItem,
     276            1 :         }
     277              : 
     278            1 :         if item.Consumable != nil {
     279            1 :                 entitySpec.Consumable = &gc.Consumable{
     280            1 :                         UsableScene: item.Consumable.UsableScene,
     281            1 :                         TargetType: gc.TargetType{
     282            1 :                                 TargetGroup: item.Consumable.TargetGroup,
     283            1 :                                 TargetNum:   item.Consumable.TargetNum,
     284            1 :                         },
     285            1 :                 }
     286              :         }
     287              : 
     288            1 :         if item.ProvidesHealing != nil {
     289            1 :                 entitySpec.ProvidesHealing = newProvidesHealingFromAPI(item.ProvidesHealing)
     290            1 :         }
     291            1 :         if item.ProvidesNutrition != nil {
     292            1 :                 entitySpec.ProvidesNutrition = &gc.ProvidesNutrition{Amount: *item.ProvidesNutrition}
     293            1 :         }
     294              :         // stageLength を持つ食料は腐敗する。RotUpdatedTurn は spawn 時に刻印するためここでは 0 のまま
     295            1 :         if item.StageLength != nil {
     296            1 :                 entitySpec.Perishable = &gc.Perishable{StageLength: consts.Turn(*item.StageLength)}
     297            1 :         }
     298            1 :         if item.InflictsDamage != nil {
     299            1 :                 entitySpec.InflictsDamage = &gc.InflictsDamage{Amount: *item.InflictsDamage}
     300            1 :         }
     301            1 :         if item.Remedy != nil {
     302            1 :                 treats := make([]gc.ConditionType, 0, len(item.Remedy.Treats))
     303            1 :                 for _, t := range item.Remedy.Treats {
     304            1 :                         treats = append(treats, gc.ConditionType(t))
     305            1 :                 }
     306            1 :                 entitySpec.Remedy = &gc.Remedy{
     307            1 :                         Treats:  treats,
     308            1 :                         Potency: consts.Percent(item.Remedy.Potency),
     309            1 :                 }
     310              :         }
     311              : 
     312            1 :         if item.Ammo != nil {
     313            1 :                 var ammoAmmoTag rawschema.AmmoTag
     314            1 :                 if item.Ammo.AmmoTag != nil {
     315            1 :                         ammoAmmoTag = *item.Ammo.AmmoTag
     316            1 :                 }
     317            1 :                 entitySpec.Ammo = &gc.Ammo{
     318            1 :                         AmmoTag:       ammoAmmoTag,
     319            1 :                         DamageBonus:   item.Ammo.DamageBonus,
     320            1 :                         AccuracyBonus: item.Ammo.AccuracyBonus,
     321            1 :                 }
     322              :         }
     323              : 
     324            1 :         if item.Melee != nil {
     325            1 :                 entitySpec.Melee = parseMelee(item.Melee)
     326            1 :         }
     327            1 :         if item.Fire != nil {
     328            1 :                 entitySpec.Fire = parseFire(item.Fire)
     329            1 :         }
     330              : 
     331            1 :         var bonus gc.EquipBonus
     332            1 :         if item.EquipBonus != nil {
     333            1 :                 bonus = gc.EquipBonus{
     334            1 :                         Vitality:  item.EquipBonus.Vitality,
     335            1 :                         Strength:  item.EquipBonus.Strength,
     336            1 :                         Sensation: item.EquipBonus.Sensation,
     337            1 :                         Dexterity: item.EquipBonus.Dexterity,
     338            1 :                         Agility:   item.EquipBonus.Agility,
     339            1 :                 }
     340              :         }
     341              : 
     342            1 :         if item.Wearable != nil {
     343            1 :                 entitySpec.Wearable = &gc.Wearable{
     344            1 :                         Defense:           item.Wearable.Defense,
     345            1 :                         EquipmentCategory: item.Wearable.EquipmentCategory,
     346            1 :                         EquipBonus:        bonus,
     347            1 :                         InsulationCold:    item.Wearable.InsulationCold,
     348            1 :                         InsulationHeat:    item.Wearable.InsulationHeat,
     349            1 :                 }
     350              :         }
     351              : 
     352            1 :         if item.CubeModule != nil {
     353            1 :                 entitySpec.CubeModule = &gc.CubeModule{
     354            1 :                         RangeBonus:        consts.Tile(item.CubeModule.RangeBonus),
     355            1 :                         FuelCapacityBonus: consts.Heat(item.CubeModule.FuelCapacityBonus),
     356            1 :                 }
     357              :         }
     358              : 
     359            1 :         entitySpec.Value = &gc.Value{Value: item.Value}
     360            1 : 
     361            1 :         if item.Weight != nil {
     362            1 :                 mg, err := consts.ParseWeight(*item.Weight)
     363            1 :                 if err != nil {
     364            1 :                         return gc.EntitySpec{}, fmt.Errorf("item '%s' weight: %w", name, err)
     365            1 :                 }
     366            1 :                 entitySpec.Weight = &gc.Weight{Milligram: mg}
     367              :         }
     368              : 
     369            1 :         if item.Book != nil {
     370            1 :                 book, err := newBookFromAPI(item.Book)
     371            1 :                 if err != nil {
     372            1 :                         return gc.EntitySpec{}, err
     373            1 :                 }
     374            1 :                 entitySpec.Book = book
     375              :         }
     376              : 
     377              :         // 携行光源。装備すると StatsChangedSystem が owner の LightSource へ転写する
     378            1 :         entitySpec.LightSource = toGCLightSource(item.LightSource)
     379            1 : 
     380              :         // 材質。可燃性と燃焼熱量の算出根拠。観察メニューで見せるためエンティティに保持する
     381            1 :         if item.Material != nil {
     382            1 :                 entitySpec.Material = &gc.Material{Kind: *item.Material}
     383            1 :         }
     384              : 
     385              :         // 火種。所持していると隣接の燃焼物に着火できる道具
     386            1 :         if item.FireStarter != nil {
     387            1 :                 entitySpec.FireStarter = &gc.FireStarter{}
     388            1 :         }
     389              : 
     390              :         // 脱出の装置。使うとクリアになる
     391            1 :         if item.EscapeDevice != nil {
     392            0 :                 entitySpec.EscapeDevice = &gc.EscapeDevice{}
     393            0 :         }
     394            1 :         if item.CubeCore != nil {
     395            0 :                 entitySpec.CubeCore = &gc.CubeCore{}
     396            0 :         }
     397              : 
     398              :         // フィールドの相互作用。既定は拾えるアイテム。装着アイテムは applyDeployable が設備に応じて上書きする
     399            1 :         entitySpec.Interactable = &gc.Interactable{Interactions: []gc.InteractionKind{gc.InteractionItem}}
     400            1 :         if item.Deployable != nil {
     401            1 :                 if err := applyDeployable(&entitySpec, item.Deployable, name); err != nil {
     402            1 :                         return gc.EntitySpec{}, err
     403            1 :                 }
     404              :         }
     405              : 
     406            1 :         return entitySpec, nil
     407              : }
     408              : 
     409              : // applyDeployable は装着アイテムの設備設定を1箇所に集める。マーカーと能力ごとのコンポーネントを付ける。
     410              : // 装着は設備画面で扱うので拾える相互作用は与えない。新設備は能力の枝を1つ足す。
     411              : // 能力枝を持たない装着、raw の空 [items.deployable] は Deployable マーカーだけを付ける。工作台が例。
     412              : func applyDeployable(entitySpec *gc.EntitySpec, dep *rawschema.Deployable, name string) error {
     413            1 :         entitySpec.Deployable = &gc.Deployable{}
     414            1 :         entitySpec.Interactable = &gc.Interactable{Interactions: []gc.InteractionKind{}}
     415            1 :         if dep.Storage != nil {
     416            1 :                 mg, err := consts.ParseWeight(dep.Storage.MaxWeight)
     417            1 :                 if err != nil {
     418            1 :                         return fmt.Errorf("item '%s' deployable storage: %w", name, err)
     419            1 :                 }
     420            1 :                 entitySpec.WeightCapacity = &gc.WeightCapacity{Max: mg}
     421            1 :                 entitySpec.Interactable = &gc.Interactable{Interactions: []gc.InteractionKind{gc.InteractionStorage}}
     422              :         }
     423              :         // 携行光源と装着照明はどちらも実体の LightSource を使うが共存できず後勝ちになる。
     424              :         // 片方が痕跡なく消える矛盾記述なので、後勝ちを許さず error で弾く
     425            1 :         if dep.LightSource != nil {
     426            1 :                 if entitySpec.LightSource != nil {
     427            1 :                         return fmt.Errorf("item '%s': carried lightSource and deployable lightSource conflict", name)
     428            1 :                 }
     429            1 :                 entitySpec.LightSource = toGCLightSource(dep.LightSource)
     430              :         }
     431            1 :         if dep.Bedding != nil {
     432            1 :                 entitySpec.Bedding = toGCBedding(dep.Bedding)
     433            1 :         }
     434            1 :         return nil
     435              : }
     436              : 
     437              : // NewRecipeSpec は指定された名前のレシピのEntitySpecを生成する
     438              : func NewRecipeSpec(raws rawschema.Raws, name string) (gc.EntitySpec, error) {
     439            2 :         recipe, ok := FindByKey(raws.Recipes, func(r rawschema.Recipe) string { return r.Id }, name)
     440            1 :         if !ok {
     441            1 :                 return gc.EntitySpec{}, NewKeyNotFoundError(name, "Recipes")
     442            1 :         }
     443              : 
     444            1 :         entitySpec := gc.EntitySpec{}
     445            1 :         entitySpec.Name = &gc.Name{Name: i18n.Msgid(recipe.Name)}
     446            1 :         entitySpec.Recipe = &gc.Recipe{}
     447            1 :         for _, input := range recipe.Inputs {
     448            1 :                 entitySpec.Recipe.Inputs = append(entitySpec.Recipe.Inputs, gc.RecipeInput{ID: input.Id, Amount: input.Amount})
     449            1 :         }
     450              : 
     451              :         // 説明文や分類のため、マッチしたitemの定義から持ってくる
     452            1 :         itemSpec, err := NewItemSpec(raws, recipe.Id)
     453            1 :         if err != nil {
     454            1 :                 return gc.EntitySpec{}, fmt.Errorf("%s: %w", "failed to generate item for recipe", err)
     455            1 :         }
     456            1 :         entitySpec.Description = &gc.Description{Description: itemSpec.Description.Description}
     457            1 :         if itemSpec.Melee != nil {
     458            1 :                 entitySpec.Melee = itemSpec.Melee
     459            1 :         }
     460            1 :         if itemSpec.Fire != nil {
     461            1 :                 entitySpec.Fire = itemSpec.Fire
     462            1 :         }
     463            1 :         if itemSpec.Wearable != nil {
     464            1 :                 entitySpec.Wearable = itemSpec.Wearable
     465            1 :         }
     466            1 :         if itemSpec.Consumable != nil {
     467            1 :                 entitySpec.Consumable = itemSpec.Consumable
     468            1 :         }
     469            1 :         if itemSpec.Value != nil {
     470            1 :                 entitySpec.Value = itemSpec.Value
     471            1 :         }
     472            1 :         if itemSpec.Weight != nil {
     473            1 :                 entitySpec.Weight = itemSpec.Weight
     474            1 :         }
     475              : 
     476            1 :         return entitySpec, nil
     477              : }
     478              : 
     479              : // NewWeaponSpec は指定された名前の武器のEntitySpecを生成する
     480              : func NewWeaponSpec(raws rawschema.Raws, name string) (gc.EntitySpec, error) {
     481              :         // 武器はアイテムの一種なので、Itemsから検索して存在確認
     482            1 :         if _, err := FindItem(raws, name); err != nil {
     483            1 :                 return gc.EntitySpec{}, err
     484            1 :         }
     485              : 
     486            1 :         itemSpec, err := NewItemSpec(raws, name)
     487            1 :         if err != nil {
     488            1 :                 return gc.EntitySpec{}, fmt.Errorf("failed to generate weapon spec: %w", err)
     489            1 :         }
     490              : 
     491              :         // Melee/Fire のいずれも持たない場合は武器ではない
     492            1 :         if itemSpec.Melee == nil && itemSpec.Fire == nil {
     493            1 :                 return gc.EntitySpec{}, fmt.Errorf("%s is not a weapon (Melee/Fire component missing)", name)
     494            1 :         }
     495              : 
     496            1 :         return itemSpec, nil
     497              : }
     498              : 
     499              : // PlayerMemberID は player を持つ member の id を返す。読み込み時にちょうど1つあることを確かめる
     500              : func PlayerMemberID(raws rawschema.Raws) (string, error) {
     501            1 :         members := PtrSlice(raws.Members)
     502            1 :         for i := range members {
     503            1 :                 if members[i].Player != nil && *members[i].Player {
     504            1 :                         return members[i].Id, nil
     505            1 :                 }
     506              :         }
     507            1 :         return "", errPlayerMemberMissing
     508              : }
     509              : 
     510              : // NewMemberSpec は指定された名前のメンバーのEntitySpecを生成する
     511              : func NewMemberSpec(raws rawschema.Raws, name string) (gc.EntitySpec, error) {
     512            2 :         member, ok := FindByKey(raws.Members, func(m rawschema.Member) string { return m.Id }, name)
     513            1 :         if !ok {
     514            1 :                 return gc.EntitySpec{}, NewKeyNotFoundError(name, "Members")
     515            1 :         }
     516              : 
     517            1 :         entitySpec := gc.EntitySpec{}
     518            1 :         entitySpec.Name = &gc.Name{Name: i18n.Msgid(member.Name)}
     519            1 :         entitySpec.RawID = &gc.RawID{ID: member.Id}
     520            1 :         entitySpec.TurnBased = &gc.TurnBased{AP: gc.IntPool{Current: 100, Max: 100}} // TODO: Abilitiesから計算する
     521            1 :         entitySpec.SpriteRender = &gc.SpriteRender{
     522            1 :                 SpriteSheetName: member.SpriteSheetName,
     523            1 :                 SpriteKey:       member.SpriteKey,
     524            1 :                 AnimKeys:        PtrSlice(member.AnimKeys),
     525            1 :                 Depth:           gc.DepthNumPlayer,
     526            1 :         }
     527            1 :         entitySpec.Abilities = &gc.Abilities{
     528            1 :                 Vitality:  gc.Ability{Base: member.Abilities.Vitality},
     529            1 :                 Strength:  gc.Ability{Base: member.Abilities.Strength},
     530            1 :                 Sensation: gc.Ability{Base: member.Abilities.Sensation},
     531            1 :                 Dexterity: gc.Ability{Base: member.Abilities.Dexterity},
     532            1 :                 Agility:   gc.Ability{Base: member.Abilities.Agility},
     533            1 :                 Defense:   gc.Ability{Base: member.Abilities.Defense},
     534            1 :         }
     535            1 :         entitySpec.HP = &gc.HP{}
     536            1 :         entitySpec.WeightCapacity = &gc.WeightCapacity{}
     537            1 :         // 体重は能力値の体格から算出する。売買や運搬で member 自身の重量として扱う
     538            1 :         entitySpec.Weight = &gc.Weight{Milligram: entitySpec.Abilities.BodyWeight()}
     539            1 : 
     540              :         // 戦闘者共通の健康機構。不調が身体機能を下げ、命中や速度へ効く
     541            1 :         entitySpec.Skills = gc.NewSkills()
     542            1 :         entitySpec.HealthStatus = &gc.HealthStatus{}
     543            1 :         if member.Player != nil && *member.Player {
     544            1 :                 entitySpec.Player = &gc.Player{}
     545            1 :         }
     546              : 
     547              :         // テーブル名はロード時に参照検証済みで、ここで失敗するのは整合性バグ
     548            1 :         if member.CommandTableId != nil {
     549            1 :                 ct, err := GetCommandTable(raws, *member.CommandTableId)
     550            1 :                 if err != nil {
     551            1 :                         return gc.EntitySpec{}, fmt.Errorf("failed to get command table for member '%s': %w", name, err)
     552            1 :                 }
     553            1 :                 entitySpec.CommandTable = &gc.CommandTable{Name: ct.Id}
     554              :         }
     555              : 
     556            1 :         if member.DropTableId != nil {
     557            1 :                 dt, err := GetDropTable(raws, *member.DropTableId)
     558            1 :                 if err != nil {
     559            1 :                         return gc.EntitySpec{}, fmt.Errorf("failed to get drop table for member '%s': %w", name, err)
     560            1 :                 }
     561            1 :                 entitySpec.DropTable = &gc.DropTable{Name: dt.Id}
     562              :         }
     563              : 
     564            1 :         entitySpec.LightSource = toGCLightSource(member.LightSource)
     565            1 : 
     566              :         // 味方と敵の派閥は NewPlayerSpec と NewEnemySpec が付ける。raw が指せるのは中立だけ
     567            1 :         if member.FactionType != nil && *member.FactionType == rawschema.FactionNeutral {
     568            1 :                 entitySpec.FactionNeutral = &gc.FactionNeutral{}
     569            1 :         }
     570              : 
     571              :         // AI の組み立て。SoloAIとして構築し、スポーン関数がそのまま使う
     572              :         {
     573            1 :                 solo := gc.SoloAI{
     574            1 :                         CombatDefault: rawschema.Attack,
     575            1 :                         CombatCurrent: rawschema.Attack,
     576            1 :                 }
     577            1 :                 if member.CombatPolicy != nil && *member.CombatPolicy != "" {
     578            1 :                         solo.CombatDefault = *member.CombatPolicy
     579            1 :                         solo.CombatCurrent = *member.CombatPolicy
     580            1 :                 }
     581            1 :                 if member.MovementPattern != nil && *member.MovementPattern != "" {
     582            1 :                         solo.Movement = *member.MovementPattern
     583            1 :                 }
     584            1 :                 entitySpec.SoloAI = &solo
     585              :         }
     586              : 
     587            1 :         if member.Dialog != nil {
     588            1 :                 entitySpec.Dialog = &gc.Dialog{
     589            1 :                         MessageKey: member.Dialog.MessageKey,
     590            1 :                 }
     591            1 :                 entitySpec.Interactable = &gc.Interactable{Interactions: []gc.InteractionKind{gc.InteractionTalk}}
     592            1 :         }
     593              : 
     594            1 :         return entitySpec, nil
     595              : }
     596              : 
     597              : // NewPlayerSpec は指定された名前のプレイヤーのEntitySpecを生成する
     598              : func NewPlayerSpec(raws rawschema.Raws, name string) (gc.EntitySpec, error) {
     599            1 :         entitySpec, err := NewMemberSpec(raws, name)
     600            1 :         if err != nil {
     601            1 :                 return gc.EntitySpec{}, err
     602            1 :         }
     603            1 :         entitySpec.FactionAlly = &gc.FactionAlly{}
     604            1 :         entitySpec.Player = &gc.Player{}
     605            1 :         entitySpec.Hunger = gc.NewHunger()
     606            1 :         entitySpec.Fatigue = gc.NewFatigue()
     607            1 :         entitySpec.SoloAI = nil
     608            1 :         return entitySpec, nil
     609              : }
     610              : 
     611              : // NewEnemySpec は指定された名前の敵のEntitySpecを生成する
     612              : func NewEnemySpec(raws rawschema.Raws, name string) (gc.EntitySpec, error) {
     613            1 :         entitySpec, err := NewMemberSpec(raws, name)
     614            1 :         if err != nil {
     615            1 :                 return gc.EntitySpec{}, err
     616            1 :         }
     617            1 :         entitySpec.FactionEnemy = &gc.FactionEnemy{}
     618            1 : 
     619            1 :         return entitySpec, nil
     620              : }
     621              : 
     622              : // GetCommandTable は指定された名前のコマンドテーブルを取得する
     623              : func GetCommandTable(raws rawschema.Raws, name string) (rawschema.CommandTable, error) {
     624            2 :         ct, ok := FindByKey(raws.CommandTables, func(c rawschema.CommandTable) string { return c.Id }, name)
     625            1 :         if !ok {
     626            1 :                 return rawschema.CommandTable{}, NewKeyNotFoundError(name, "CommandTables")
     627            1 :         }
     628            1 :         return ct, nil
     629              : }
     630              : 
     631              : // GetDropTable は指定された名前のドロップテーブルを取得する
     632              : func GetDropTable(raws rawschema.Raws, name string) (rawschema.DropTable, error) {
     633            2 :         dt, ok := FindByKey(raws.DropTables, func(d rawschema.DropTable) string { return d.Id }, name)
     634            1 :         if !ok {
     635            1 :                 return rawschema.DropTable{}, NewKeyNotFoundError(name, "DropTables")
     636            1 :         }
     637            1 :         return dt, nil
     638              : }
     639              : 
     640              : // errItemGroupNotExist は指定した ID のアイテムグループもアイテムコレクションも存在しないときに返す。
     641              : var errItemGroupNotExist = errors.New("item group does not exist")
     642              : 
     643              : // GetItemGroup は指定された名前のアイテムグループを取得する
     644              : func GetItemGroup(raws rawschema.Raws, name string) (rawschema.ItemGroup, error) {
     645            2 :         ig, ok := FindByKey(raws.ItemGroups, func(g rawschema.ItemGroup) string { return g.Id }, name)
     646            1 :         if !ok {
     647            1 :                 return rawschema.ItemGroup{}, fmt.Errorf("%w: %s", errItemGroupNotExist, name)
     648            1 :         }
     649            1 :         return ig, nil
     650              : }
     651              : 
     652              : // GetItemCollection は指定された id のアイテムコレクションを取得する
     653              : func GetItemCollection(raws rawschema.Raws, id string) (rawschema.ItemCollection, error) {
     654            2 :         c, ok := FindByKey(raws.ItemCollections, func(c rawschema.ItemCollection) string { return c.Id }, id)
     655            1 :         if !ok {
     656            1 :                 return rawschema.ItemCollection{}, NewKeyNotFoundError(id, "ItemCollections")
     657            1 :         }
     658            1 :         return c, nil
     659              : }
     660              : 
     661              : // GetItemTable は指定された名前のアイテムテーブルを取得する
     662              : func GetItemTable(raws rawschema.Raws, name string) (rawschema.ItemTable, error) {
     663            2 :         it, ok := FindByKey(raws.ItemTables, func(t rawschema.ItemTable) string { return t.Id }, name)
     664            1 :         if !ok {
     665            1 :                 return rawschema.ItemTable{}, NewKeyNotFoundError(name, "ItemTables")
     666            1 :         }
     667            1 :         return it, nil
     668              : }
     669              : 
     670              : // GetEnemyTable は指定された名前の敵テーブルを取得する
     671              : func GetEnemyTable(raws rawschema.Raws, name string) (rawschema.EnemyTable, error) {
     672            2 :         et, ok := FindByKey(raws.EnemyTables, func(t rawschema.EnemyTable) string { return t.Id }, name)
     673            1 :         if !ok {
     674            1 :                 return rawschema.EnemyTable{}, NewKeyNotFoundError(name, "EnemyTables")
     675            1 :         }
     676            1 :         return et, nil
     677              : }
     678              : 
     679              : // DungeonReachable はダンジョンの行を遺跡の入口から入れるダンジョンとして扱うかを返す。重み0の行はデバッグ用
     680              : func DungeonReachable(d *rawschema.Dungeon) bool {
     681            1 :         return d.EntranceWeight > 0
     682            1 : }
     683              : 
     684              : // GetDungeon は id のダンジョンの行を返す
     685              : func GetDungeon(raws rawschema.Raws, id string) (rawschema.Dungeon, error) {
     686            2 :         d, ok := FindByKey(raws.Dungeons, func(d rawschema.Dungeon) string { return d.Id }, id)
     687            1 :         if !ok {
     688            1 :                 return rawschema.Dungeon{}, NewKeyNotFoundError(id, "Dungeons")
     689            1 :         }
     690            1 :         return d, nil
     691              : }
     692              : 
     693              : // GetFacility は id の施設宣言を返す。未登録は false。
     694              : func GetFacility(raws rawschema.Raws, id string) (rawschema.Facility, bool) {
     695            2 :         return FindByKey(raws.Facilities, func(f rawschema.Facility) string { return f.Id }, id)
     696              : }
     697              : 
     698              : // FacilityLootedChance は施設 fac の収納家具が荒らされて空になっている確率を百分率で返す。省略は0。
     699              : func FacilityLootedChance(raws rawschema.Raws, fac string) (int, error) {
     700            1 :         f, ok := GetFacility(raws, fac)
     701            1 :         if !ok {
     702            1 :                 return 0, NewKeyNotFoundError(fac, "Facilities")
     703            1 :         }
     704            1 :         if f.LootedChance == nil {
     705            1 :                 return 0, nil
     706            1 :         }
     707            1 :         return int(*f.LootedChance), nil
     708              : }
     709              : 
     710              : // GetLandmark は id のランドマーク宣言を返す。未登録は false。
     711              : func GetLandmark(raws rawschema.Raws, id string) (rawschema.Landmark, bool) {
     712            2 :         return FindByKey(raws.Landmarks, func(l rawschema.Landmark) string { return l.Id }, id)
     713              : }
     714              : 
     715              : // GetScatterZone は id の散布ゾーン宣言を返す。未登録は false。
     716              : func GetScatterZone(raws rawschema.Raws, id string) (rawschema.ScatterZone, bool) {
     717            2 :         return FindByKey(raws.ScatterZones, func(z rawschema.ScatterZone) string { return z.Id }, id)
     718              : }
     719              : 
     720              : // GetMapGlyph は id の地図記号宣言を返す。未登録は false。
     721              : func GetMapGlyph(raws rawschema.Raws, id string) (rawschema.MapGlyph, bool) {
     722            2 :         return FindByKey(raws.MapGlyphs, func(m rawschema.MapGlyph) string { return m.Id }, id)
     723              : }
     724              : 
     725              : // GetChunkGlyph は持ち主の行を持たないチャンクの種類 chunk を描く地図記号の行を返す
     726              : func GetChunkGlyph(raws rawschema.Raws, chunk rawschema.GlyphChunk) (rawschema.MapGlyph, bool) {
     727            1 :         for _, g := range PtrSlice(raws.MapGlyphs) {
     728            1 :                 if g.Chunk != nil && *g.Chunk == chunk {
     729            1 :                         return g, true
     730            1 :                 }
     731              :         }
     732            1 :         return rawschema.MapGlyph{}, false
     733              : }
     734              : 
     735              : // GetTile は指定された名前のタイルを取得する
     736              : // 計画段階でタイルの性質(Walkableなど)を参照する場合に使用する
     737              : func GetTile(raws rawschema.Raws, id string) (rawschema.Tile, error) {
     738            2 :         tile, ok := FindByKey(raws.Tiles, func(t rawschema.Tile) string { return t.Id }, id)
     739            1 :         if !ok {
     740            1 :                 return rawschema.Tile{}, NewKeyNotFoundError(id, "Tiles")
     741            1 :         }
     742            1 :         return tile, nil
     743              : }
     744              : 
     745              : // NewTileSpec は指定された名前のタイルのEntitySpecを生成する
     746              : // 実際にエンティティを生成する際に使用する
     747              : func NewTileSpec(raws rawschema.Raws, name string, x, y consts.Tile, autoTileIndex *int) (gc.EntitySpec, error) {
     748            1 :         tileRaw, err := GetTile(raws, name)
     749            1 :         if err != nil {
     750            0 :                 return gc.EntitySpec{}, err
     751            0 :         }
     752              : 
     753            1 :         entitySpec := gc.EntitySpec{}
     754            1 :         entitySpec.Name = &gc.Name{Name: i18n.Msgid(tileRaw.Name)}
     755            1 :         entitySpec.RawID = &gc.RawID{ID: tileRaw.Id}
     756            1 :         entitySpec.Description = &gc.Description{Description: i18n.Msgid(tileRaw.Description)}
     757            1 :         entitySpec.GridElement = &gc.GridElement{Coord: consts.Coord[consts.Tile]{X: x, Y: y}}
     758            1 : 
     759              :         // SpriteRenderを設定
     760            1 :         sprite := toGCSpriteRender(tileRaw.SpriteRender)
     761            1 :         // オートタイルインデックスが指定されている場合はspriteKeyを動的に生成
     762            1 :         if autoTileIndex != nil {
     763            1 :                 sprite.SpriteKey = fmt.Sprintf("%s_%d", tileRaw.SpriteRender.SpriteKey, *autoTileIndex)
     764            1 :         }
     765            1 :         entitySpec.SpriteRender = &sprite
     766            1 : 
     767              :         // BlockPassがtrueの場合は通行を遮断
     768            1 :         if tileRaw.BlockPass {
     769            1 :                 entitySpec.BlockPass = &gc.BlockPass{}
     770            1 :         }
     771              : 
     772              :         // BlockViewがtrueの場合は視界を遮断
     773            1 :         if tileRaw.BlockView {
     774            1 :                 entitySpec.BlockView = &gc.BlockView{}
     775            1 :         }
     776              : 
     777            1 :         entitySpec.Tile = &gc.Tile{}
     778            1 : 
     779            1 :         env := TileEnvironmentOf(tileRaw)
     780            1 :         entitySpec.TileEnvironment = &env
     781            1 : 
     782            1 :         return entitySpec, nil
     783              : }
     784              : 
     785              : // TileIsTall はタイルの行が高さのあるタイルかを返す。描画順が高さのあるもの DepthNumTaller なら高い。
     786              : // 高いタイルのオートタイルは細い輪郭を前提にするので、通れるマスに接しない厚い塊の内側は虚空にする
     787              : func TileIsTall(t rawschema.Tile) bool {
     788            1 :         return gc.DepthNum(int(t.SpriteRender.Depth)) == gc.DepthNumTaller
     789            1 : }
     790              : 
     791              : // TileEnvironmentOf はタイルの行だけから決まる環境属性を返す。水の影響は周りのタイルで決まるので含まない
     792              : func TileEnvironmentOf(t rawschema.Tile) gc.TileEnvironment {
     793            1 :         env := gc.TileEnvironment{Shelter: TileShelter(t)}
     794            1 :         if t.Foliage != nil {
     795            1 :                 env.Foliage = *t.Foliage
     796            1 :         }
     797            1 :         if t.SnowMeltPercent != nil {
     798            1 :                 env.SnowMeltPercent = *t.SnowMeltPercent
     799            1 :         }
     800            1 :         return env
     801              : }
     802              : 
     803              : // TileShelter はタイルの行の囲われを返す。行が省けば屋外
     804              : func TileShelter(t rawschema.Tile) rawschema.Shelter {
     805            1 :         if t.Shelter == nil {
     806            1 :                 return rawschema.Outdoor
     807            1 :         }
     808            1 :         return *t.Shelter
     809              : }
     810              : 
     811              : // GetProp は指定された名前の置物の設定を取得する
     812              : func GetProp(raws rawschema.Raws, name string) (rawschema.Prop, error) {
     813            2 :         prop, ok := FindByKey(raws.Props, func(p rawschema.Prop) string { return p.Id }, name)
     814            1 :         if !ok {
     815            1 :                 return rawschema.Prop{}, NewKeyNotFoundError(name, "Props")
     816            1 :         }
     817            1 :         return prop, nil
     818              : }
     819              : 
     820              : // NewPropSpec は指定された名前の置物のEntitySpecを生成する
     821              : func NewPropSpec(raws rawschema.Raws, name string) (gc.EntitySpec, error) {
     822            1 :         propRaw, err := GetProp(raws, name)
     823            1 :         if err != nil {
     824            1 :                 return gc.EntitySpec{}, err
     825            1 :         }
     826              : 
     827            1 :         entitySpec := gc.EntitySpec{}
     828            1 :         entitySpec.Prop = &gc.Prop{}
     829            1 :         entitySpec.Name = &gc.Name{Name: i18n.Msgid(propRaw.Name)}
     830            1 :         entitySpec.RawID = &gc.RawID{ID: propRaw.Id}
     831            1 :         entitySpec.Description = &gc.Description{Description: i18n.Msgid(propRaw.Description)}
     832            1 : 
     833              :         // SpriteRenderの設定(AnimKeysを含む)
     834            1 :         spriteRender := toGCSpriteRender(propRaw.SpriteRender)
     835            1 :         if animKeys := PtrSlice(propRaw.AnimKeys); len(animKeys) > 0 {
     836            1 :                 spriteRender.AnimKeys = animKeys
     837            1 :         }
     838            1 :         entitySpec.SpriteRender = &spriteRender
     839            1 : 
     840            1 :         if propRaw.BlockPass && propRaw.PassCost != nil {
     841            1 :                 return gc.EntitySpec{}, fmt.Errorf("prop '%s': %w", name, errBlockPassWithPassCost)
     842            1 :         }
     843            1 :         if propRaw.BlockPass {
     844            1 :                 entitySpec.BlockPass = &gc.BlockPass{}
     845            1 :         }
     846            1 :         if propRaw.BlockView {
     847            1 :                 entitySpec.BlockView = &gc.BlockView{}
     848            1 :         }
     849            1 :         if propRaw.PassCost != nil {
     850            1 :                 entitySpec.PassCost = &gc.PassCost{Value: *propRaw.PassCost}
     851            1 :         }
     852              :         // 各条件に対応するインタラクションを蓄積する。
     853              :         // 1つのPropが複数のインタラクションを持てる
     854            1 :         var interactions []gc.InteractionKind
     855            1 : 
     856            1 :         if propRaw.Door != nil {
     857            1 :                 entitySpec.Door = &gc.Door{
     858            1 :                         IsOpen:      false,
     859            1 :                         Orientation: gc.DoorOrientationHorizontal,
     860            1 :                 }
     861            1 :                 interactions = append(interactions, gc.InteractionDoor)
     862            1 :         }
     863              : 
     864            1 :         if propRaw.Hp != nil {
     865            1 :                 entitySpec.HP = &gc.HP{Max: *propRaw.Hp, Current: *propRaw.Hp}
     866            1 :                 interactions = append(interactions, gc.InteractionMelee)
     867            1 :         }
     868              : 
     869            1 :         entitySpec.LightSource = toGCLightSource(propRaw.LightSource)
     870            1 :         entitySpec.HeatSource = toGCHeatSource(propRaw.HeatSource)
     871            1 :         entitySpec.Bedding = toGCBedding(propRaw.Bedding)
     872            1 : 
     873            1 :         if propRaw.WarpNextTrigger != nil {
     874            1 :                 interactions = append(interactions, gc.InteractionPortalNext)
     875            1 :         }
     876              : 
     877            1 :         if propRaw.WarpPrevTrigger != nil {
     878            1 :                 interactions = append(interactions, gc.InteractionPortalPrev)
     879            1 :         }
     880              : 
     881            1 :         if propRaw.Storage != nil {
     882            1 :                 mg, err := consts.ParseWeight(propRaw.Storage.MaxWeight)
     883            1 :                 if err != nil {
     884            1 :                         return gc.EntitySpec{}, fmt.Errorf("container '%s' max weight: %w", name, err)
     885            1 :                 }
     886            1 :                 entitySpec.WeightCapacity = &gc.WeightCapacity{Max: mg}
     887            1 :                 entitySpec.Unsearched = &gc.Unsearched{}
     888            1 :                 interactions = append(interactions, gc.InteractionStorage)
     889              :         }
     890              : 
     891            1 :         if len(interactions) > 0 {
     892            1 :                 entitySpec.Interactable = &gc.Interactable{Interactions: interactions}
     893            1 :         }
     894              : 
     895            1 :         return entitySpec, nil
     896              : }
     897              : 
     898              : // FindDisassembly は指定された名前の prop の分解定義を返す
     899              : func FindDisassembly(raws rawschema.Raws, name string) (*rawschema.Disassembly, bool) {
     900            2 :         prop, ok := FindByKey(raws.Props, func(p rawschema.Prop) string { return p.Id }, name)
     901            1 :         if !ok || prop.Disassembly == nil {
     902            1 :                 return nil, false
     903            1 :         }
     904            1 :         return prop.Disassembly, true
     905              : }
     906              : 
     907              : // FindTool は指定された名前のアイテムの道具の性質を返す
     908              : func FindTool(raws rawschema.Raws, name string) (*rawschema.Tool, bool) {
     909            2 :         item, ok := FindByKey(raws.Items, func(i rawschema.Item) string { return i.Id }, name)
     910            1 :         if !ok || item.Tool == nil {
     911            1 :                 return nil, false
     912            1 :         }
     913            1 :         return item.Tool, true
     914              : }
     915              : 
     916              : // GetProfession は指定されたIDの職業データを返す
     917              : func GetProfession(raws rawschema.Raws, id string) (rawschema.Profession, error) {
     918            2 :         prof, ok := FindByKey(raws.Professions, func(p rawschema.Profession) string { return p.Id }, id)
     919            1 :         if !ok {
     920            1 :                 return rawschema.Profession{}, NewKeyNotFoundError(id, "Professions")
     921            1 :         }
     922            1 :         return prof, nil
     923              : }
     924              : 
     925              : // SelectCommandByWeight はコマンドテーブルから重み付きランダム選択する
     926              : func SelectCommandByWeight(ct rawschema.CommandTable, rng *rand.Rand) (string, error) {
     927            2 :         i, ok := consts.Pick(rng, ct.Entries, func(e rawschema.CommandTableEntry) float64 { return e.Weight })
     928            1 :         if !ok {
     929            1 :                 return "", nil
     930            1 :         }
     931            1 :         return ct.Entries[i].Id, nil
     932              : }
     933              : 
     934              : // SelectDropByWeight はドロップテーブルから重み付きランダム選択する。何も落とさないときは空文字を返す。
     935              : func SelectDropByWeight(dt rawschema.DropTable, rng *rand.Rand) (string, error) {
     936            1 :         weights := make([]float64, 0, len(dt.Entries)+1)
     937            1 :         var nothing float64
     938            1 :         if dt.Nothing != nil {
     939            1 :                 nothing = *dt.Nothing
     940            1 :         }
     941            1 :         weights = append(weights, nothing)
     942            1 :         for _, e := range dt.Entries {
     943            1 :                 weights = append(weights, e.Weight)
     944            1 :         }
     945            2 :         i, ok := consts.Pick(rng, weights, func(w float64) float64 { return w })
     946            1 :         if !ok || i == 0 {
     947            1 :                 return "", nil
     948            1 :         }
     949            1 :         return dt.Entries[i-1].Id, nil
     950              : }
     951              : 
     952              : // MinDanger は spawn テーブルが引ける最小の危険度。テーブルは1始まり設計で、これ未満は
     953              : // 危険度の指定漏れとしてエラーにする。
     954              : const MinDanger = 1
     955              : 
     956              : // errDangerBelowMinimum は MinDanger 未満の危険度で抽選したときに返す
     957              : var errDangerBelowMinimum = errors.New("danger is below the minimum")
     958              : 
     959              : // EnemyEntriesAt は敵テーブルのうち、危険度 danger で出る行を返す。
     960              : func EnemyEntriesAt(et rawschema.EnemyTable, danger int) []rawschema.EnemyTableEntry {
     961            2 :         return inDanger(et.Entries, danger, func(e rawschema.EnemyTableEntry) (int, int) { return e.MinDanger, e.MaxDanger })
     962              : }
     963              : 
     964              : // ItemEntriesAt はアイテムテーブルのうち、危険度 danger で出る行を返す。
     965              : func ItemEntriesAt(it rawschema.ItemTable, danger int) []rawschema.ItemTableEntry {
     966            2 :         return inDanger(it.Entries, danger, func(e rawschema.ItemTableEntry) (int, int) { return e.MinDanger, e.MaxDanger })
     967              : }
     968              : 
     969              : func inDanger[T any](entries []T, danger int, rangeOf func(T) (lo, hi int)) []T {
     970            1 :         out := make([]T, 0, len(entries))
     971            1 :         for _, e := range entries {
     972            1 :                 if lo, hi := rangeOf(e); lo <= danger && danger <= hi {
     973            1 :                         out = append(out, e)
     974            1 :                 }
     975              :         }
     976            1 :         return out
     977              : }
     978              : 
     979              : func checkDanger(danger int) error {
     980            1 :         if danger < MinDanger {
     981            1 :                 return fmt.Errorf("%w: danger %d, minimum %d; the caller must specify a valid danger", errDangerBelowMinimum, danger, MinDanger)
     982            1 :         }
     983            1 :         return nil
     984              : }
     985              : 
     986              : // DrawFromItemTable はアイテムテーブルから危険度に合うグループを重みで1つ選び、そのグループから1回ぶんを引く。
     987              : // グループの引き方は SelectFromItemGroup に従う。
     988              : func DrawFromItemTable(raws rawschema.Raws, it rawschema.ItemTable, rng *rand.Rand, danger int) ([]DrawnItem, error) {
     989            1 :         if err := checkDanger(danger); err != nil {
     990            1 :                 return nil, err
     991            1 :         }
     992            1 :         entries := ItemEntriesAt(it, danger)
     993            2 :         i, ok := consts.Pick(rng, entries, func(e rawschema.ItemTableEntry) float64 { return e.Weight })
     994            1 :         if !ok {
     995            1 :                 return nil, nil
     996            1 :         }
     997            1 :         return SelectFromItemGroup(raws, entries[i].Id, rng)
     998              : }
     999              : 
    1000              : // SelectEnemyByWeight は敵テーブルから危険度を考慮して重み付きランダム選択する
    1001              : func SelectEnemyByWeight(et rawschema.EnemyTable, rng *rand.Rand, danger int) (string, error) {
    1002            1 :         if err := checkDanger(danger); err != nil {
    1003            1 :                 return "", err
    1004            1 :         }
    1005            1 :         entries := EnemyEntriesAt(et, danger)
    1006            2 :         i, ok := consts.Pick(rng, entries, func(e rawschema.EnemyTableEntry) float64 { return e.Weight })
    1007            1 :         if !ok {
    1008            1 :                 return "", nil
    1009            1 :         }
    1010            1 :         return entries[i].Id, nil
    1011              : }
    1012              : 
    1013              : // NewConditionDefs は raw の conditions、bodyParts、attackTypes から不調の定義の表を組み立てる。
    1014              : // 参照の実在は rawcheck のスキーマの検証が確かめる前提で、見つからない部位はエラーにする
    1015              : func NewConditionDefs(raws rawschema.Raws) (gc.ConditionDefs, error) {
    1016            1 :         var parts [gc.BodyPartCount]gc.BodyPartDef
    1017            1 :         for _, row := range PtrSlice(raws.BodyParts) {
    1018            1 :                 bp, ok := gc.BodyPartByID(row.Id)
    1019            1 :                 if !ok {
    1020            0 :                         return gc.ConditionDefs{}, NewKeyNotFoundError(row.Id, "BodyParts")
    1021            0 :                 }
    1022            1 :                 parts[bp] = gc.BodyPartDef{Name: i18n.Msgid(row.Name), HitWeight: row.HitWeight}
    1023              :         }
    1024              : 
    1025            1 :         conditions := PtrSlice(raws.Conditions)
    1026            1 :         conds := make(map[gc.ConditionType]gc.ConditionDef, len(conditions))
    1027            1 :         for _, row := range conditions {
    1028            1 :                 def := gc.ConditionDef{
    1029            1 :                         Name:                    i18n.Msgid(row.Name),
    1030            1 :                         Description:             i18n.Msgid(row.Description),
    1031            1 :                         PainPerSeverity:         row.PainPerSeverity,
    1032            1 :                         BodyFuncDropPerSeverity: row.BodyFuncDropPerSeverity,
    1033            1 :                 }
    1034            1 :                 if row.Recovery != nil {
    1035            1 :                         def.Recovery = *row.Recovery
    1036            1 :                 }
    1037            1 :                 if row.WorsenPer != nil {
    1038            1 :                         def.WorsenPer = *row.WorsenPer
    1039            1 :                 }
    1040            1 :                 if row.RecoverPer != nil {
    1041            1 :                         def.RecoverPer = *row.RecoverPer
    1042            1 :                 }
    1043            1 :                 if row.BloodDropPerSeverity != nil {
    1044            1 :                         def.BloodDropPerSeverity = *row.BloodDropPerSeverity
    1045            1 :                 }
    1046            1 :                 if row.Cause != nil {
    1047            1 :                         def.Cause = gc.DeathCause(*row.Cause)
    1048            1 :                 }
    1049            1 :                 if row.Onset != nil {
    1050            1 :                         def.Onset = *row.Onset
    1051            1 :                 }
    1052            1 :                 for _, id := range PtrSlice(row.Parts) {
    1053            1 :                         bp, ok := gc.BodyPartByID(id)
    1054            1 :                         if !ok {
    1055            0 :                                 return gc.ConditionDefs{}, NewKeyNotFoundError(id, "BodyParts")
    1056            0 :                         }
    1057            1 :                         def.Parts = append(def.Parts, bp)
    1058              :                 }
    1059            1 :                 conds[gc.ConditionType(row.Id)] = def
    1060              :         }
    1061              : 
    1062            1 :         attackTypes := PtrSlice(raws.AttackTypes)
    1063            1 :         injuries := make(map[rawschema.AttackCategory]gc.ConditionType, len(attackTypes))
    1064            1 :         for i := range attackTypes {
    1065            1 :                 injuries[attackTypes[i].Id] = gc.ConditionType(attackTypes[i].Injury)
    1066            1 :         }
    1067            1 :         return gc.NewConditionDefs(conds, parts, injuries), nil
    1068              : }
    1069              : 
    1070              : // NewSkillDefs は raw の skills、skillCategories、attackTypes からスキルの定義の表を組み立てる。
    1071              : // 命中の効果倍率は攻撃の種類の射程から、目減りさせる身体機能を決める。
    1072              : // カテゴリは skillCategories の行の順に、カテゴリ内のスキルは skills の行の順に並べる
    1073              : func NewSkillDefs(raws rawschema.Raws) (gc.SkillDefs, error) {
    1074            1 :         rows := PtrSlice(raws.Skills)
    1075            1 :         skills := make(map[rawschema.SkillId]gc.SkillDef, len(rows))
    1076            1 :         proficiencies := make(map[rawschema.ProficiencyId]gc.ProficiencyDef)
    1077            1 :         idsByCategory := make(map[string][]rawschema.SkillId)
    1078            1 :         var resists []gc.ResistDef
    1079            1 :         for i := range rows {
    1080            1 :                 row := &rows[i]
    1081            1 :                 id := row.Id
    1082            1 :                 skills[id] = gc.SkillDef{
    1083            1 :                         Name:     i18n.Msgid(row.Name),
    1084            1 :                         Summary:  i18n.Msgid(row.Summary),
    1085            1 :                         GainedBy: i18n.Msgid(row.GainedBy),
    1086            1 :                         Effect:   i18n.Msgid(row.Effect),
    1087            1 :                         Ability:  row.Ability,
    1088            1 :                 }
    1089            1 :                 for _, p := range PtrSlice(row.Proficiencies) {
    1090            1 :                         proficiencies[p.Id] = gc.ProficiencyDef{Skill: id, PerLevel: p.PerLevel}
    1091            1 :                         if p.Resists != nil {
    1092            1 :                                 resists = append(resists, gc.ResistDef{Element: *p.Resists, Proficiency: p.Id})
    1093            1 :                         }
    1094              :                 }
    1095            1 :                 idsByCategory[row.Category] = append(idsByCategory[row.Category], id)
    1096              :         }
    1097              : 
    1098            1 :         catRows := PtrSlice(raws.SkillCategories)
    1099            1 :         categories := make([]gc.SkillCategory, 0, len(catRows))
    1100            1 :         for _, c := range catRows {
    1101            1 :                 categories = append(categories, gc.SkillCategory{Name: i18n.Msgid(c.Name), IDs: idsByCategory[c.Id]})
    1102            1 :         }
    1103            1 :         attackTypes := PtrSlice(raws.AttackTypes)
    1104            1 :         weapons := make([]gc.WeaponDef, 0, len(attackTypes))
    1105            1 :         for i := range attackTypes {
    1106            1 :                 row := &attackTypes[i]
    1107            1 :                 weapons = append(weapons, gc.WeaponDef{
    1108            1 :                         AttackType:  row.Id,
    1109            1 :                         Name:        i18n.Msgid(row.Name),
    1110            1 :                         Range:       row.Range,
    1111            1 :                         RangeParams: gc.RangeParams{OptimalRange: deref(row.OptimalRange), MaxRange: deref(row.MaxRange), PenaltyPerTile: deref(row.PenaltyPerTile)},
    1112            1 :                         Skill:       row.Skill,
    1113            1 :                         Damage:      row.Damage,
    1114            1 :                         Accuracy:    row.Accuracy,
    1115            1 :                 })
    1116            1 :                 accuracy, ok := proficiencies[row.Accuracy]
    1117            1 :                 if !ok {
    1118            0 :                         return gc.SkillDefs{}, NewKeyNotFoundError(string(row.Accuracy), "Proficiencies")
    1119            0 :                 }
    1120            1 :                 accuracy.BodyFunc = gc.BodyFuncManipulation
    1121            1 :                 if row.Range == rawschema.AttackRangeRanged {
    1122            1 :                         accuracy.BodyFunc = gc.BodyFuncSight
    1123            1 :                 }
    1124            1 :                 proficiencies[row.Accuracy] = accuracy
    1125              :         }
    1126            1 :         toolSkills := make(map[rawschema.ToolCategory]rawschema.SkillId)
    1127            1 :         for _, row := range PtrSlice(raws.ToolCategories) {
    1128            1 :                 if row.Skill != nil {
    1129            1 :                         toolSkills[row.Id] = *row.Skill
    1130            1 :                 }
    1131              :         }
    1132            1 :         return gc.SkillDefs{Skills: skills, Categories: categories, Proficiencies: proficiencies, Weapons: weapons, Resists: resists, ToolSkills: toolSkills}, nil
    1133              : }
    1134              : 
    1135              : // 生成された enum を、順序に意味を持つ Go の型へ写す表。Go の型は大小の比較や配列の添字に使う。
    1136              : // 表が enum の全値を持つことはテストで確かめる
    1137              : var (
    1138              :         weatherKinds = map[rawschema.WeatherId]gc.WeatherKind{
    1139              :                 rawschema.Clear:    gc.WeatherClear,
    1140              :                 rawschema.Cloudy:   gc.WeatherCloudy,
    1141              :                 rawschema.Rain:     gc.WeatherRain,
    1142              :                 rawschema.Snow:     gc.WeatherSnow,
    1143              :                 rawschema.Blizzard: gc.WeatherBlizzard,
    1144              :                 rawschema.ColdSnap: gc.WeatherColdSnap,
    1145              :         }
    1146              :         seasons = map[rawschema.SeasonId]gc.Season{
    1147              :                 rawschema.Spring: gc.SeasonSpring,
    1148              :                 rawschema.Summer: gc.SeasonSummer,
    1149              :                 rawschema.Autumn: gc.SeasonAutumn,
    1150              :                 rawschema.Winter: gc.SeasonWinter,
    1151              :         }
    1152              :         timesOfDay = map[rawschema.TimeOfDayId]gc.TimeOfDay{
    1153              :                 rawschema.Dawn:     gc.TimeDawn,
    1154              :                 rawschema.Morning:  gc.TimeMorning,
    1155              :                 rawschema.Noon:     gc.TimeDay,
    1156              :                 rawschema.Evening:  gc.TimeEvening,
    1157              :                 rawschema.Night:    gc.TimeNight,
    1158              :                 rawschema.Midnight: gc.TimeMidnight,
    1159              :         }
    1160              :         severities = map[rawschema.ConditionSeverity]gc.Severity{
    1161              :                 rawschema.ConditionSeverityMinor:  gc.SeverityMinor,
    1162              :                 rawschema.ConditionSeverityMedium: gc.SeverityMedium,
    1163              :                 rawschema.ConditionSeveritySevere: gc.SeveritySevere,
    1164              :         }
    1165              : )
    1166              : 
    1167              : // NewTileEnvDefs は raw の shelterEffects、waterEffects、foliageEffects から、囲われの受け方と、水と植生がタイルの気温に足す補正の表を組み立てる
    1168              : func NewTileEnvDefs(raws rawschema.Raws) gc.TileEnvDefs {
    1169            1 :         defs := gc.TileEnvDefs{Shelters: map[rawschema.Shelter]gc.ShelterDef{}, Water: map[rawschema.WaterExposure]int{}, Foliage: map[rawschema.Foliage]int{}}
    1170            1 :         for _, row := range PtrSlice(raws.ShelterEffects) {
    1171            1 :                 defs.Shelters[row.Id] = gc.ShelterDef{Name: i18n.Msgid(row.Name), AnchorTemp: row.AnchorTemp, InfluencePercent: row.InfluencePercent, Covered: row.Covered, DaylightPercent: row.DaylightPercent}
    1172            1 :         }
    1173            1 :         for _, row := range PtrSlice(raws.WaterEffects) {
    1174            1 :                 defs.Water[row.Id] = row.TempModifier
    1175            1 :         }
    1176            1 :         for _, row := range PtrSlice(raws.FoliageEffects) {
    1177            1 :                 defs.Foliage[row.Id] = row.TempModifier
    1178            1 :         }
    1179            1 :         return defs
    1180              : }
    1181              : 
    1182              : // NewWeatherDefs は raw の weathers から天候の定義の表を組み立てる。id と季節は enum なのでスキーマ検証で尽くされる
    1183              : func NewWeatherDefs(raws rawschema.Raws) gc.WeatherDefs {
    1184            1 :         var kinds [gc.NumWeatherKind]gc.WeatherDef
    1185            1 :         for _, row := range PtrSlice(raws.Weathers) {
    1186            1 :                 def := gc.WeatherDef{
    1187            1 :                         Name:          i18n.Msgid(row.Name),
    1188            1 :                         Effect:        gc.WeatherEffect{TempModifier: row.TempModifier, VisionDelta: row.VisionDelta},
    1189            1 :                         Severity:      row.Severity,
    1190            1 :                         SpellTurnsMin: row.SpellTurnsMin,
    1191            1 :                         SpellTurnsMax: row.SpellTurnsMax,
    1192            1 :                 }
    1193            1 :                 for _, sw := range row.Seasons {
    1194            1 :                         def.SeasonWeights[seasons[sw.Id]] = sw.Weight
    1195            1 :                 }
    1196            1 :                 kinds[weatherKinds[row.Id]] = def
    1197              :         }
    1198            1 :         return gc.WeatherDefs{Kinds: kinds}
    1199              : }
    1200              : 
    1201              : // NewCalendarDefs は raw の timesOfDay と seasons から時間帯と季節の表を組み立てる。id は enum なので検証で尽くされる
    1202              : func NewCalendarDefs(raws rawschema.Raws) gc.CalendarDefs {
    1203            1 :         var defs gc.CalendarDefs
    1204            1 :         for _, row := range PtrSlice(raws.TimesOfDay) {
    1205            1 :                 defs.TimesOfDay[timesOfDay[row.Id]] = gc.TimeOfDayDef{
    1206            1 :                         Name:         i18n.Msgid(row.Name),
    1207            1 :                         TempModifier: row.TempModifier,
    1208            1 :                         Daylight:     row.Daylight,
    1209            1 :                         AmbientColor: [3]float64{row.AmbientColor.R, row.AmbientColor.G, row.AmbientColor.B},
    1210            1 :                 }
    1211              :         }
    1212            1 :         for _, row := range PtrSlice(raws.Seasons) {
    1213            1 :                 defs.Seasons[seasons[row.Id]] = gc.SeasonDef{Name: i18n.Msgid(row.Name), Temp: row.Temp}
    1214            1 :         }
    1215            1 :         return defs
    1216              : }
    1217              : 
    1218              : // NewMaterialDefs は raw の materials から材質の表示名と燃焼熱量と分解の戻し先の表を組み立てる
    1219              : func NewMaterialDefs(raws rawschema.Raws) (gc.MaterialDefs, error) {
    1220            1 :         defs := make(gc.MaterialDefs, len(PtrSlice(raws.Materials)))
    1221            1 :         for _, row := range PtrSlice(raws.Materials) {
    1222            1 :                 def := gc.MaterialDef{Name: i18n.Msgid(row.Name), HeatPerKg: row.HeatPerKg}
    1223            1 :                 if row.Disassembly != nil {
    1224            1 :                         per, err := consts.ParseWeight(row.Disassembly.PerWeight)
    1225            1 :                         if err != nil {
    1226            0 :                                 return nil, fmt.Errorf("material %s: %w", row.Id, err)
    1227            0 :                         }
    1228            1 :                         def.Disassembly = &gc.MaterialDisassembly{Item: row.Disassembly.Item, PerWeight: per}
    1229              :                 }
    1230            1 :                 defs[row.Id] = def
    1231              :         }
    1232            1 :         return defs, nil
    1233              : }
    1234              : 
    1235              : // toRGBA は raw の色を color.RGBA にする。nil なら nil を返す
    1236              : func toRGBA(c *rawschema.RGBAColor) *color.RGBA {
    1237            1 :         if c == nil {
    1238            1 :                 return nil
    1239            1 :         }
    1240            1 :         return &color.RGBA{R: c.R, G: c.G, B: c.B, A: c.A}
    1241              : }
    1242              : 
    1243              : // NewNeedDefs は raw の hungerStages、fatigueStages、freshnessStages から空腹と疲労と鮮度の段階の表を組み立てる
    1244              : func NewNeedDefs(raws rawschema.Raws) gc.NeedDefs {
    1245            1 :         conditionOf := func(s *rawschema.ConditionSeverity) gc.Severity {
    1246            1 :                 if s == nil {
    1247            1 :                         return gc.SeverityNone
    1248            1 :                 }
    1249            1 :                 return severities[*s]
    1250              :         }
    1251            1 :         hunger := make([]gc.HungerStage, 0, len(PtrSlice(raws.HungerStages)))
    1252            1 :         for _, row := range PtrSlice(raws.HungerStages) {
    1253            1 :                 hunger = append(hunger, gc.HungerStage{
    1254            1 :                         Level: row.Id, Name: i18n.Msgid(row.Name), From: row.From, Condition: conditionOf(row.Severity),
    1255            1 :                         ReachedLog: i18n.Msgid(deref(row.ReachedLog)), WakesSleeper: deref(row.WakesSleeper), Badge: toRGBA(row.BadgeColor),
    1256            1 :                 })
    1257            1 :         }
    1258            1 :         fatigue := make([]gc.FatigueStage, 0, len(PtrSlice(raws.FatigueStages)))
    1259            1 :         for _, row := range PtrSlice(raws.FatigueStages) {
    1260            1 :                 fatigue = append(fatigue, gc.FatigueStage{
    1261            1 :                         Level: row.Id, Name: i18n.Msgid(row.Name), From: row.From, Condition: conditionOf(row.Severity),
    1262            1 :                         CanSleep: row.CanSleep, Badge: toRGBA(row.BadgeColor),
    1263            1 :                 })
    1264            1 :         }
    1265            1 :         freshness := make([]gc.FreshnessDef, 0, len(PtrSlice(raws.FreshnessStages)))
    1266            1 :         for _, row := range PtrSlice(raws.FreshnessStages) {
    1267            1 :                 freshness = append(freshness, gc.FreshnessDef{
    1268            1 :                         Level: row.Id, From: row.From,
    1269            1 :                         Name: i18n.Msgid(row.Name), NutritionPercent: row.NutritionPercent, EatLog: i18n.Msgid(row.EatLog), Marker: row.Marker,
    1270            1 :                         IllnessChancePercent: deref(row.IllnessChancePercent),
    1271            1 :                 })
    1272            1 :         }
    1273            1 :         return gc.NeedDefs{Hunger: hunger, Fatigue: fatigue, Freshness: freshness}
    1274              : }
        

Generated by: LCOV version 2.0-1