LCOV - code coverage report
Current view: top level - maptemplate - palette.go Coverage Total Hit
Test: coverage.lcov Lines: 93.4 % 182 170
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package maptemplate
       2              : 
       3              : import (
       4              :         "errors"
       5              :         "fmt"
       6              :         "io"
       7              :         "maps"
       8              :         "math/rand/v2"
       9              :         "slices"
      10              :         "unicode/utf8"
      11              : 
      12              :         "github.com/kijimaD/ruins/internal/consts"
      13              : 
      14              :         "github.com/kijimaD/ruins/assets"
      15              :         "github.com/pelletier/go-toml/v2"
      16              : )
      17              : 
      18              : var (
      19              :         // errPaletteIDEmpty はパレットIDが空のときに返す
      20              :         errPaletteIDEmpty = errors.New("palette ID is empty")
      21              :         // errPaletteNoDefinition は文字の定義がどれもないときに返す
      22              :         errPaletteNoDefinition = errors.New("palette has no char definition")
      23              :         // errPaletteKeyNotSingleChar はパレットのキーが1文字でないときに返す
      24              :         errPaletteKeyNotSingleChar = errors.New("key must be a single character")
      25              :         // errPaletteTileRequired はPropsやNPCsのtileが未指定のときに返す
      26              :         errPaletteTileRequired = errors.New("tile is required")
      27              :         // errPaletteCharDuplicated は同じ文字が複数の分類で使われているときに返す
      28              :         errPaletteCharDuplicated = errors.New("char is duplicated")
      29              :         // errPalettePropIDAmbiguous は prop の id と候補の両方か、どちらも無いときに返す
      30              :         errPalettePropIDAmbiguous = errors.New("prop needs exactly one of id or candidates")
      31              :         // errPaletteItemGroupRequired は床の戦利品の itemGroup が未指定のときに返す
      32              :         errPaletteItemGroupRequired = errors.New("itemGroup is required")
      33              :         // errPaletteChanceOutOfRange は確率が 1 から 100 の外のときに返す
      34              :         errPaletteChanceOutOfRange = errors.New("chance must be in 1..100")
      35              :         // errPaletteRepeatInvalid は回数の範囲が [最小, 最大] で 0 <= 最小 <= 最大 でないときに返す
      36              :         errPaletteRepeatInvalid = errors.New("repeat must be [min, max] with 0 <= min <= max")
      37              : )
      38              : 
      39              : // PaletteEntry はパレットのProp/NPCマッピングの1エントリ
      40              : type PaletteEntry struct {
      41              :         ID   string `toml:"id"`
      42              :         Tile string `toml:"tile,omitempty"`
      43              :         // Candidates は prop を重み付きで選ぶ候補。ID とどちらか一方だけを書く
      44              :         Candidates []WeightedID `toml:"candidates,omitempty"`
      45              :         // LootTable は収納の中身を引く itemTables の id。収納でなければ空
      46              :         LootTable string `toml:"lootTable,omitempty"`
      47              : }
      48              : 
      49              : // WeightedID は重み付きの候補の1つ
      50              : type WeightedID struct {
      51              :         ID     string `toml:"id"`
      52              :         Weight int    `toml:"weight"`
      53              : }
      54              : 
      55              : // ItemEntry は床に落ちる戦利品を置く文字の定義。家具など別の分類と同じ文字にも重ねて書け、そのマスの上に置く
      56              : type ItemEntry struct {
      57              :         // Tile は下に敷く地形。別の分類と重ねるときはそちらの地形を使うので省ける
      58              :         Tile string `toml:"tile,omitempty"`
      59              :         // ItemGroup は戦利品を引く itemGroups の id
      60              :         ItemGroup string `toml:"itemGroup"`
      61              :         // Chance は1回ごとにグループから引く確率。1 から 100 の百分率で、省くと必ず引く
      62              :         Chance *int `toml:"chance,omitempty"`
      63              :         // Repeat は引く回数の範囲 [最小, 最大]。省くと1回
      64              :         Repeat []int `toml:"repeat,omitempty"`
      65              : }
      66              : 
      67              : // BeingEntry は施設の敵の表から1体置く文字の定義
      68              : type BeingEntry struct {
      69              :         // Tile は下に敷く地形
      70              :         Tile string `toml:"tile"`
      71              :         // Chance は置く確率。1 から 100 の百分率で、省くと必ず置く
      72              :         Chance *int `toml:"chance,omitempty"`
      73              : }
      74              : 
      75              : // nullChunk は部品の候補で、何も置かないことを表す名前
      76              : const nullChunk = "null"
      77              : 
      78              : // NestedEntry は文字の位置を左上に部品を1つ置く定義。候補の nullChunk は何も置かない
      79              : type NestedEntry struct {
      80              :         // Tile は文字のマスに敷く地形。部品が置かれると上書きされ、何も置かない候補のときだけ残る
      81              :         Tile string `toml:"tile"`
      82              :         // Chunks は置く部品の候補
      83              :         Chunks []WeightedChunkRef `toml:"chunks"`
      84              : }
      85              : 
      86              : // WeightedChunkRef は部品の候補の1つ
      87              : type WeightedChunkRef struct {
      88              :         Name   string `toml:"name"`
      89              :         Weight int    `toml:"weight"`
      90              : }
      91              : 
      92              : // Palette はマップ生成用のパレット定義
      93              : // terrainとPropsとNPCの文字マッピングを提供する
      94              : type Palette struct {
      95              :         ID          string                  `toml:"id"`
      96              :         Description string                  `toml:"description"`
      97              :         Terrain     map[string]string       `toml:"terrain,omitempty"` // {文字: terrain名}
      98              :         Props       map[string]PaletteEntry `toml:"props,omitempty"`   // {文字: Prop定義}
      99              :         NPCs        map[string]PaletteEntry `toml:"npcs,omitempty"`    // {文字: NPC定義}
     100              :         Items       map[string]ItemEntry    `toml:"items,omitempty"`   // {文字: 床の戦利品}
     101              :         Beings      map[string]BeingEntry   `toml:"beings,omitempty"`  // {文字: 施設の敵の表から引く敵}
     102              :         Nested      map[string]NestedEntry  `toml:"nested,omitempty"`  // {文字: その位置を左上に置く部品}
     103              : }
     104              : 
     105              : // PaletteFile はTOMLファイルのルート構造
     106              : type PaletteFile struct {
     107              :         Palette Palette `toml:"palette"`
     108              : }
     109              : 
     110              : // PaletteLoader はパレット定義の読み込みを担当する
     111              : type PaletteLoader struct{}
     112              : 
     113              : // NewPaletteLoader はPaletteLoaderを生成する
     114              : func NewPaletteLoader() *PaletteLoader {
     115            1 :         return &PaletteLoader{}
     116            1 : }
     117              : 
     118              : // Load はio.Readerからパレット定義を読み込む
     119              : func (l *PaletteLoader) Load(r io.Reader) (*Palette, error) {
     120            1 :         data, err := io.ReadAll(r)
     121            1 :         if err != nil {
     122            0 :                 return nil, fmt.Errorf("failed to read palette: %w", err)
     123            0 :         }
     124              : 
     125            1 :         var file PaletteFile
     126            1 :         if err := toml.Unmarshal(data, &file); err != nil {
     127            1 :                 return nil, fmt.Errorf("failed to parse palette TOML: %w", err)
     128            1 :         }
     129              : 
     130            1 :         if err := l.validate(&file.Palette); err != nil {
     131            1 :                 return nil, fmt.Errorf("failed to validate palette: %w", err)
     132            1 :         }
     133              : 
     134            1 :         return &file.Palette, nil
     135              : }
     136              : 
     137              : // LoadFile はTOMLファイルからパレット定義を読み込む
     138              : func (l *PaletteLoader) LoadFile(path string) (*Palette, error) {
     139            1 :         f, err := assets.FS.Open(path)
     140            1 :         if err != nil {
     141            1 :                 return nil, fmt.Errorf("failed to read palette file: %w", err)
     142            1 :         }
     143            2 :         defer func() { _ = f.Close() }()
     144              : 
     145            1 :         return l.Load(f)
     146              : }
     147              : 
     148              : // validate はパレット定義の妥当性を検証する
     149              : func (l *PaletteLoader) validate(p *Palette) error {
     150            1 :         if p.ID == "" {
     151            1 :                 return errPaletteIDEmpty
     152            1 :         }
     153              : 
     154            1 :         if len(p.Terrain)+len(p.Props)+len(p.NPCs)+len(p.Items)+len(p.Beings)+len(p.Nested) == 0 {
     155            1 :                 return errPaletteNoDefinition
     156            1 :         }
     157              : 
     158            1 :         for char := range p.Terrain {
     159            1 :                 if utf8.RuneCountInString(char) != 1 {
     160            1 :                         return fmt.Errorf("terrain %w: %q", errPaletteKeyNotSingleChar, char)
     161            1 :                 }
     162              :         }
     163            1 :         for char, entry := range p.Props {
     164            1 :                 if err := validateTileChar("props", char, entry.Tile); err != nil {
     165            1 :                         return err
     166            1 :                 }
     167            1 :                 if (entry.ID == "") == (len(entry.Candidates) == 0) {
     168            1 :                         return fmt.Errorf("props %w: %q", errPalettePropIDAmbiguous, char)
     169            1 :                 }
     170            1 :                 for _, c := range entry.Candidates {
     171            1 :                         if c.Weight <= 0 {
     172            1 :                                 return fmt.Errorf("props %q candidate %q: %w: %d", char, c.ID, errNonPositiveWeight, c.Weight)
     173            1 :                         }
     174              :                 }
     175              :         }
     176            1 :         for char, entry := range p.NPCs {
     177            1 :                 if err := validateTileChar("npcs", char, entry.Tile); err != nil {
     178            1 :                         return err
     179            1 :                 }
     180              :         }
     181            1 :         for char, entry := range p.Beings {
     182            1 :                 if err := validateTileChar("beings", char, entry.Tile); err != nil {
     183            1 :                         return err
     184            1 :                 }
     185            1 :                 if !validChance(entry.Chance) {
     186            1 :                         return fmt.Errorf("beings %q: %w: %d", char, errPaletteChanceOutOfRange, *entry.Chance)
     187            1 :                 }
     188              :         }
     189              : 
     190            1 :         if err := validateItems(p.Items); err != nil {
     191            1 :                 return err
     192            1 :         }
     193            1 :         if err := validateNested(p.Nested); err != nil {
     194            0 :                 return err
     195            0 :         }
     196              : 
     197              :         // 床の戦利品は家具の上にも置くので、items の文字は他の分類と重ねてよい。重複の検査から外す
     198            1 :         used := make(map[string]string)
     199            1 :         for _, c := range []struct {
     200            1 :                 category string
     201            1 :                 chars    []string
     202            1 :         }{
     203            1 :                 {"terrain", keysOf(p.Terrain)},
     204            1 :                 {"props", keysOf(p.Props)},
     205            1 :                 {"npcs", keysOf(p.NPCs)},
     206            1 :                 {"beings", keysOf(p.Beings)},
     207            1 :                 {"nested", keysOf(p.Nested)},
     208            1 :         } {
     209            1 :                 for _, char := range c.chars {
     210            1 :                         if other, ok := used[char]; ok {
     211            1 :                                 return fmt.Errorf("%w: %q between %s and %s", errPaletteCharDuplicated, char, other, c.category)
     212            1 :                         }
     213            1 :                         used[char] = c.category
     214              :                 }
     215              :         }
     216              : 
     217            1 :         return nil
     218              : }
     219              : 
     220              : // validateItems は床の戦利品の文字の定義を検証する
     221              : func validateItems(items map[string]ItemEntry) error {
     222            1 :         for char, entry := range items {
     223            1 :                 if utf8.RuneCountInString(char) != 1 {
     224            0 :                         return fmt.Errorf("items %w: %q", errPaletteKeyNotSingleChar, char)
     225            0 :                 }
     226            1 :                 if entry.ItemGroup == "" {
     227            1 :                         return fmt.Errorf("items %w: %q", errPaletteItemGroupRequired, char)
     228            1 :                 }
     229            1 :                 if !validChance(entry.Chance) {
     230            1 :                         return fmt.Errorf("items %q: %w: %d", char, errPaletteChanceOutOfRange, *entry.Chance)
     231            1 :                 }
     232            1 :                 if entry.Repeat != nil && (len(entry.Repeat) != 2 || entry.Repeat[0] < 0 || entry.Repeat[0] > entry.Repeat[1]) {
     233            1 :                         return fmt.Errorf("items %q: %w: %v", char, errPaletteRepeatInvalid, entry.Repeat)
     234            1 :                 }
     235              :         }
     236            1 :         return nil
     237              : }
     238              : 
     239              : // validateNested は部品の文字の定義を検証する
     240              : func validateNested(nested map[string]NestedEntry) error {
     241            1 :         for char, entry := range nested {
     242            1 :                 if err := validateTileChar("nested", char, entry.Tile); err != nil {
     243            0 :                         return err
     244            0 :                 }
     245            1 :                 if len(entry.Chunks) == 0 {
     246            0 :                         return fmt.Errorf("nested %w: %q", errNoChunkCandidate, char)
     247            0 :                 }
     248            1 :                 for _, c := range entry.Chunks {
     249            1 :                         if c.Weight <= 0 {
     250            0 :                                 return fmt.Errorf("nested %q chunk %q: %w: %d", char, c.Name, errNonPositiveWeight, c.Weight)
     251            0 :                         }
     252              :                 }
     253              :         }
     254            1 :         return nil
     255              : }
     256              : 
     257              : // validateTileChar は文字が1文字で、下に敷く地形を持つことを検証する
     258              : func validateTileChar(category, char, tile string) error {
     259            1 :         if utf8.RuneCountInString(char) != 1 {
     260            1 :                 return fmt.Errorf("%s %w: %q", category, errPaletteKeyNotSingleChar, char)
     261            1 :         }
     262            1 :         if tile == "" {
     263            1 :                 return fmt.Errorf("%s %w: %q", category, errPaletteTileRequired, char)
     264            1 :         }
     265            1 :         return nil
     266              : }
     267              : 
     268              : // keysOf は map のキーを返す
     269              : func keysOf[V any](m map[string]V) []string {
     270            1 :         return slices.Collect(maps.Keys(m))
     271            1 : }
     272              : 
     273              : // MergePalettes は複数のパレットをマージする
     274              : // 後のパレットが前のパレットを上書きする
     275              : func MergePalettes(palettes ...*Palette) *Palette {
     276            1 :         merged := &Palette{
     277            1 :                 ID:          "merged",
     278            1 :                 Description: "merged palette",
     279            1 :                 Terrain:     make(map[string]string),
     280            1 :                 Props:       make(map[string]PaletteEntry),
     281            1 :                 NPCs:        make(map[string]PaletteEntry),
     282            1 :                 Items:       make(map[string]ItemEntry),
     283            1 :                 Beings:      make(map[string]BeingEntry),
     284            1 :                 Nested:      make(map[string]NestedEntry),
     285            1 :         }
     286              : 
     287            1 :         for _, p := range palettes {
     288            1 :                 maps.Copy(merged.Terrain, p.Terrain)
     289            1 :                 maps.Copy(merged.Props, p.Props)
     290            1 :                 maps.Copy(merged.NPCs, p.NPCs)
     291            1 :                 maps.Copy(merged.Items, p.Items)
     292            1 :                 maps.Copy(merged.Beings, p.Beings)
     293            1 :                 maps.Copy(merged.Nested, p.Nested)
     294            1 :         }
     295              : 
     296            1 :         return merged
     297              : }
     298              : 
     299              : // GetTerrain は文字からterrain名を取得する。
     300              : // Terrain定義を優先し、なければProps/NPCsのTileフィールドを参照する
     301              : func (p *Palette) GetTerrain(char string) (string, bool) {
     302            1 :         if terrain, ok := p.Terrain[char]; ok {
     303            1 :                 return terrain, true
     304            1 :         }
     305            1 :         if entry, ok := p.Props[char]; ok && entry.Tile != "" {
     306            1 :                 return entry.Tile, true
     307            1 :         }
     308            1 :         if entry, ok := p.NPCs[char]; ok && entry.Tile != "" {
     309            1 :                 return entry.Tile, true
     310            1 :         }
     311            1 :         if entry, ok := p.Items[char]; ok && entry.Tile != "" {
     312            1 :                 return entry.Tile, true
     313            1 :         }
     314            1 :         if entry, ok := p.Beings[char]; ok {
     315            1 :                 return entry.Tile, true
     316            1 :         }
     317            1 :         if entry, ok := p.Nested[char]; ok {
     318            1 :                 return entry.Tile, true
     319            1 :         }
     320            1 :         return "", false
     321              : }
     322              : 
     323              : // GetProp は文字から prop の id と収納の中身の表を引く。候補を持つ文字は rng で1つ選ぶ
     324              : func (p *Palette) GetProp(char string, rng *rand.Rand) (id, lootTable string, ok bool) {
     325            1 :         entry, ok := p.Props[char]
     326            1 :         if !ok {
     327            1 :                 return "", "", false
     328            1 :         }
     329            1 :         if len(entry.Candidates) == 0 {
     330            1 :                 return entry.ID, entry.LootTable, true
     331            1 :         }
     332            2 :         i, _ := consts.Pick(rng, entry.Candidates, func(c WeightedID) float64 { return float64(c.Weight) })
     333            1 :         return entry.Candidates[i].ID, entry.LootTable, true
     334              : }
     335              : 
     336              : // GetNPC は文字からNPC種別を取得する
     337              : func (p *Palette) GetNPC(char string) (string, bool) {
     338            1 :         entry, ok := p.NPCs[char]
     339            1 :         if !ok {
     340            1 :                 return "", false
     341            1 :         }
     342            1 :         return entry.ID, true
     343              : }
     344              : 
     345              : // roll はグループから引く回数を決める。回数の範囲から回数を選び、1回ごとに確率で引くかを決める
     346              : func (e ItemEntry) roll(rng *rand.Rand) int {
     347            1 :         n := 1
     348            1 :         if len(e.Repeat) == 2 {
     349            1 :                 n = e.Repeat[0] + rng.IntN(e.Repeat[1]-e.Repeat[0]+1)
     350            1 :         }
     351            1 :         chance := chancePercent(e.Chance)
     352            1 :         if chance == 100 {
     353            1 :                 return n
     354            1 :         }
     355            1 :         count := 0
     356            1 :         for range n {
     357            1 :                 if rng.IntN(100) < chance {
     358            1 :                         count++
     359            1 :                 }
     360              :         }
     361            1 :         return count
     362              : }
     363              : 
     364              : // validChance は確率が省かれているか、1 から 100 に収まるかを返す
     365              : func validChance(c *int) bool {
     366            1 :         return c == nil || (*c >= 1 && *c <= 100)
     367            1 : }
     368              : 
     369              : // chancePercent は確率を百分率で返す。省くと必ずなので 100 にする
     370              : func chancePercent(c *int) int {
     371            1 :         if c == nil {
     372            1 :                 return 100
     373            1 :         }
     374            1 :         return *c
     375              : }
        

Generated by: LCOV version 2.0-1