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