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