LCOV - code coverage report
Current view: top level - cmd - layoutpng.go Coverage Total Hit
Test: coverage.lcov Lines: 81.8 % 55 45
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package cmd
       2              : 
       3              : import (
       4              :         "context"
       5              :         "errors"
       6              :         "fmt"
       7              :         "hash/fnv"
       8              :         "image"
       9              :         "image/color"
      10              :         "image/draw"
      11              :         "io"
      12              :         "sort"
      13              : 
      14              :         "github.com/kijimaD/ruins/internal/maptemplate"
      15              :         "github.com/urfave/cli/v3"
      16              : )
      17              : 
      18              : // layoutCellSize はレイアウトの PNG の1マスの辺の長さ
      19              : const layoutCellSize = 8
      20              : 
      21              : // errNoLayoutArg はレイアウトの名前が渡されないときに返す
      22              : var errNoLayoutArg = errors.New("layout name is required")
      23              : 
      24              : // CmdLayoutPNG はレイアウトのテンプレートを展開し、マスを色で塗った PNG を書き出すサブコマンド
      25              : var CmdLayoutPNG = &cli.Command{
      26              :         Name:      "layoutpng",
      27              :         Usage:     "render a layout template as a png",
      28              :         ArgsUsage: "<template name>",
      29              :         Flags: []cli.Flag{
      30              :                 &cli.StringFlag{Name: outFlag, Usage: "output png path", Value: "layout.png"},
      31              :                 &cli.Uint64Flag{Name: "seed", Usage: "seed to pick variants and placements", Value: 1},
      32              :         },
      33              :         Action: runLayoutPNG,
      34              : }
      35              : 
      36              : func runLayoutPNG(_ context.Context, cmd *cli.Command) error {
      37            1 :         if !cmd.Args().Present() {
      38            1 :                 return errNoLayoutArg
      39            1 :         }
      40            1 :         loader := maptemplate.NewTemplateLoader()
      41            1 :         if err := loader.RegisterAllChunks([]string{"levels/chunks", "levels/facilities", "levels/layouts"}); err != nil {
      42            0 :                 return err
      43            0 :         }
      44            1 :         if err := loader.RegisterAllPalettes([]string{"levels/palettes"}); err != nil {
      45            0 :                 return err
      46            0 :         }
      47            1 :         _, _, cells, err := loader.LoadTemplateByName(cmd.Args().First(), cmd.Uint64("seed"))
      48            1 :         if err != nil {
      49            0 :                 return err
      50            0 :         }
      51            1 :         if err := writePNG(cmd.String(outFlag), renderLayout(cells, layoutCellSize)); err != nil {
      52            0 :                 return err
      53            0 :         }
      54            1 :         return writeLegend(cmd.Writer, cells)
      55              : }
      56              : 
      57              : var (
      58              :         propColor = color.NRGBA{R: 40, G: 40, B: 40, A: 255}
      59              :         npcColor  = color.NRGBA{R: 220, G: 40, B: 40, A: 255}
      60              : )
      61              : 
      62              : // renderLayout はマスを地形の色で塗る。設置物はマスの内側の四角、NPC はマスの中央の点で示す。
      63              : func renderLayout(cells [][]maptemplate.MapCell, size int) *image.NRGBA {
      64            1 :         width := 0
      65            1 :         for _, row := range cells {
      66            1 :                 width = max(width, len(row))
      67            1 :         }
      68            1 :         img := image.NewNRGBA(image.Rect(0, 0, width*size, len(cells)*size))
      69            1 :         for y, row := range cells {
      70            1 :                 for x, c := range row {
      71            1 :                         r := image.Rect(x*size, y*size, (x+1)*size, (y+1)*size)
      72            1 :                         draw.Draw(img, r, image.NewUniform(terrainColor(c.Terrain)), image.Point{}, draw.Src)
      73            1 :                         if c.Prop != "" {
      74            1 :                                 draw.Draw(img, r.Inset(size/4), image.NewUniform(propColor), image.Point{}, draw.Src)
      75            1 :                         }
      76            1 :                         if c.NPC != "" {
      77            1 :                                 draw.Draw(img, r.Inset(size*3/8), image.NewUniform(npcColor), image.Point{}, draw.Src)
      78            1 :                         }
      79              :                 }
      80              :         }
      81            1 :         return img
      82              : }
      83              : 
      84              : // terrainColor は地形の名前から決まる明るめの色を返す。同じ名前はいつも同じ色になる。
      85              : func terrainColor(name string) color.NRGBA {
      86            1 :         h := fnv.New32a()
      87            1 :         _, _ = h.Write([]byte(name))
      88            1 :         v := h.Sum32()
      89            1 :         return color.NRGBA{R: 96 + uint8(v%128), G: 96 + uint8((v>>8)%128), B: 96 + uint8((v>>16)%128), A: 255}
      90            1 : }
      91              : 
      92              : // writeLegend は地形の名前と色の対応を、名前の順に書く。
      93              : func writeLegend(w io.Writer, cells [][]maptemplate.MapCell) error {
      94            1 :         seen := map[string]bool{}
      95            1 :         for _, row := range cells {
      96            1 :                 for _, c := range row {
      97            1 :                         seen[c.Terrain] = true
      98            1 :                 }
      99              :         }
     100            1 :         names := make([]string, 0, len(seen))
     101            1 :         for n := range seen {
     102            1 :                 names = append(names, n)
     103            1 :         }
     104            1 :         sort.Strings(names)
     105            1 :         for _, n := range names {
     106            1 :                 c := terrainColor(n)
     107            1 :                 if _, err := fmt.Fprintf(w, "#%02x%02x%02x %s\n", c.R, c.G, c.B, n); err != nil {
     108            0 :                         return err
     109            0 :                 }
     110              :         }
     111            1 :         return nil
     112              : }
        

Generated by: LCOV version 2.0-1