Add golangci-lint

.github/workflows/build.yml

@@ -1,4 +1,4 @@
-name: Build and test
+name: Build, lint, test
 
 on:
   push:
@@ -14,12 +14,17 @@ jobs:
       - uses: actions/checkout@v3
 
       - name: Set up Go
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v5
         with:
-          go-version: '1.21'
+          go-version: '1.22'
 
       - name: Build
         run: go build -v ./...
 
+      - name: Lint
+        run: |
+          go install github.com/golangci/golangci-lint/cmd/[email protected]
+          golangci-lint run --fix=false
+
       - name: Test
         run: go test -v ./...

.golangci.yaml

@@ -0,0 +1,12 @@
+linters:
+  enable:
+    - bodyclose
+    - funlen
+    - gocognit
+    - goconst
+    - gosec
+    - nilerr
+    - nolintlint
+    # - varnamelen
+    - wastedassign
+    - wsl

cmd/panorama/main.go

@@ -31,6 +31,7 @@ func fullrender(config config.Config) error {
 		slog.Error("unable to load game description", "error", err)
 		return err
 	}
+
 	backend, err := world.NewPostgresBackend(config.System.WorldDSN)
 	if err != nil {
 		slog.Error("unable to connect to world DB", "error", err)
@@ -56,6 +57,7 @@ func run(config config.Config) error {
 	quit := make(chan bool)
 
 	slog.Info("starting web server", "address", config.Web.ListenAddress)
+
 	go func() {
 		web.Serve(&config)
 		quit <- true
@@ -76,12 +78,19 @@ func main() {
 
 	commonFlags := flag.NewFlagSet("common flags", flag.ExitOnError)
 	commonFlags.StringVar(&args.ConfigPath, "config", "config.toml", "Path to config file")
-	commonFlags.Parse(os.Args[2:])
+
+	err := commonFlags.Parse(os.Args[2:])
+	if err != nil {
+		slog.Error("unable to parse flags")
+		os.Exit(1)
+	}
 
 	slog.Info("loading config", "config_path", args.ConfigPath)
+
 	config, err := config.LoadConfig(args.ConfigPath)
 	if err != nil {
 		slog.Error("unable to load config", "error", err)
+		os.Exit(1)
 	}
 
 	switch subcommand {

internal/game/game.go

@@ -100,6 +100,7 @@ func makeMeshNode(model *mesh.Model, tiles []*image.NRGBA) NodeDefinition {
 		if i >= len(tiles) {
 			break
 		}
+
 		textures[i] = tiles[i]
 	}
 
@@ -152,6 +153,7 @@ func LoadGame(desc string, path string, modpath string) (Game, error) {
 	}
 
 	var descriptor gameDescriptor
+
 	err = json.Unmarshal(descJSON, &descriptor)
 	if err != nil {
 		return Game{}, err
@@ -163,12 +165,14 @@ func LoadGame(desc string, path string, modpath string) (Game, error) {
 	if err != nil {
 		return Game{}, err
 	}
+
 	err = mediaCache.fetchMedia(modpath)
 	if err != nil {
 		return Game{}, err
 	}
 
 	nodes := make(map[string]NodeDefinition)
+
 	for name, gameNode := range descriptor.Nodes {
 		node := ResolveNode(gameNode, mediaCache)
 
@@ -190,5 +194,6 @@ func (g *Game) NodeDef(node string) NodeDefinition {
 	if def, ok := g.Nodes[node]; ok {
 		return def
 	}
+
 	return g.unknown
 }

internal/game/media.go

@@ -20,6 +20,7 @@ type MediaCache struct {
 
 func NewMediaCache() *MediaCache {
 	dummyImage := image.NewNRGBA(image.Rect(0, 0, 2, 2))
+
 	dummyImage.SetNRGBA(0, 0, color.NRGBA{255, 0, 255, 255})
 	dummyImage.SetNRGBA(0, 1, color.NRGBA{0, 0, 0, 255})
 	dummyImage.SetNRGBA(1, 0, color.NRGBA{0, 0, 0, 255})
@@ -39,15 +40,18 @@ func (m *MediaCache) fetchMedia(path string) error {
 		}
 
 		basePath := filepath.Base(path)
+
 		switch filepath.Ext(path) {
 		case ".png":
 			img, _ := raster.LoadPNG(path)
 			m.images[basePath] = img
+
 		case ".obj":
 			model, err := mesh.LoadOBJ(path)
 			if err != nil {
 				return err
 			}
+
 			m.models[basePath] = &model
 		}
 
@@ -72,6 +76,7 @@ func (m *MediaCache) Mesh(name string) *mesh.Model {
 		return model
 	} else {
 		slog.Warn("unknown image", "name", name)
+
 		return nil
 	}
 }

internal/game/node.go

@@ -55,6 +55,7 @@ func (t DrawType) IsLiquid() bool {
 
 func (t *DrawType) UnmarshalJSON(data []byte) error {
 	var name string
+
 	err := json.Unmarshal(data, &name)
 	if err != nil {
 		return err
@@ -83,6 +84,7 @@ var ParamTypeNames = map[string]ParamType{
 
 func (t *ParamType) UnmarshalJSON(data []byte) error {
 	name := "light"
+
 	err := json.Unmarshal(data, &name)
 	if err != nil {
 		return err
@@ -133,6 +135,7 @@ var ParamType2Names = map[string]ParamType2{
 
 func (t *ParamType2) UnmarshalJSON(data []byte) error {
 	name := "none"
+
 	err := json.Unmarshal(data, &name)
 	if err != nil {
 		return err
@@ -157,13 +160,15 @@ func (n *NodeBox) UnmarshalJSON(data []byte) error {
 		Type  string        `json:"type"`
 		Fixed []interface{} `json:"fixed"`
 	}
+
 	inner := &nodeBox{}
 	if err := json.Unmarshal(data, inner); err != nil {
 		return err
 	}
 
 	n.Type = inner.Type
 	n.Fixed = make([][]float64, 0)
+
 	if inner.Type != "fixed" {
 		return nil
 	}
@@ -174,21 +179,25 @@ func (n *NodeBox) UnmarshalJSON(data []byte) error {
 
 	if _, ok := inner.Fixed[0].(float64); ok {
 		box := make([]float64, 0)
+
 		for i := 0; i < 6; i++ {
 			v, _ := inner.Fixed[i].(float64)
 			box = append(box, v)
 		}
+
 		n.Fixed = append(n.Fixed, box)
 	}
 
 	if _, ok := inner.Fixed[0].([]interface{}); ok {
 		for _, boxInterface := range inner.Fixed {
 			boxFloat64 := boxInterface.([]interface{})
 			box := make([]float64, 0)
+
 			for i := 0; i < 6; i++ {
 				v, _ := boxFloat64[i].(float64)
 				box = append(box, v)
 			}
+
 			n.Fixed = append(n.Fixed, box)
 		}
 	}
@@ -207,6 +216,7 @@ type NodeDescriptor struct {
 
 func (n *NodeDescriptor) UnmarshalJSON(data []byte) error {
 	type nodeDescriptor NodeDescriptor
+
 	inner := &nodeDescriptor{
 		DrawType:   DrawTypeNormal,
 		Tiles:      []string{},

internal/lm/matrix3.go

@@ -28,5 +28,6 @@ func (lhs *Matrix3) MulVec(rhs Vector3) Vector3 {
 	x := lhs.m[0]*rhs.X + lhs.m[1]*rhs.Y + lhs.m[2]*rhs.Z
 	y := lhs.m[3]*rhs.X + lhs.m[4]*rhs.Y + lhs.m[5]*rhs.Z
 	z := lhs.m[6]*rhs.X + lhs.m[7]*rhs.Y + lhs.m[8]*rhs.Z
+
 	return Vec3(x, y, z)
 }

internal/lm/vector2.go

@@ -16,35 +16,41 @@ func Vec2(x, y float64) Vector2 {
 func (lhs Vector2) Add(rhs Vector2) Vector2 {
 	x := lhs.X + rhs.X
 	y := lhs.Y + rhs.Y
+
 	return Vec2(x, y)
 }
 
 func (lhs Vector2) Sub(rhs Vector2) Vector2 {
 	x := lhs.X - rhs.X
 	y := lhs.Y - rhs.Y
+
 	return Vec2(x, y)
 }
 
 func (lhs Vector2) Mul(rhs Vector2) Vector2 {
 	x := lhs.X * rhs.X
 	y := lhs.Y * rhs.Y
+
 	return Vec2(x, y)
 }
 
 func (lhs Vector2) MulScalar(rhs float64) Vector2 {
 	x := lhs.X * rhs
 	y := lhs.Y * rhs
+
 	return Vec2(x, y)
 }
 
 func (lhs Vector2) Min(rhs Vector2) Vector2 {
 	x := math.Min(lhs.X, rhs.X)
 	y := math.Min(lhs.Y, rhs.Y)
+
 	return Vec2(x, y)
 }
 
 func (lhs Vector2) Max(rhs Vector2) Vector2 {
 	x := math.Max(lhs.X, rhs.X)
 	y := math.Max(lhs.Y, rhs.Y)
+
 	return Vec2(x, y)
 }

internal/lm/vector3.go

@@ -18,13 +18,15 @@ func (lhs Vector3) Add(rhs Vector3) Vector3 {
 	x := lhs.X + rhs.X
 	y := lhs.Y + rhs.Y
 	z := lhs.Z + rhs.Z
+
 	return Vec3(x, y, z)
 }
 
 func (lhs Vector3) MulScalar(rhs float64) Vector3 {
 	x := lhs.X * rhs
 	y := lhs.Y * rhs
 	z := lhs.Z * rhs
+
 	return Vec3(x, y, z)
 }
 
@@ -33,20 +35,23 @@ func (lhs Vector3) DivScalar(rhs float64) Vector3 {
 	x := lhs.X * reciprocal
 	y := lhs.Y * reciprocal
 	z := lhs.Z * reciprocal
+
 	return Vec3(x, y, z)
 }
 
 func (lhs Vector3) PowScalar(power float64) Vector3 {
 	x := math.Pow(lhs.X, power)
 	y := math.Pow(lhs.Y, power)
 	z := math.Pow(lhs.Z, power)
+
 	return Vec3(x, y, z)
 }
 
 func (lhs Vector3) Cross(rhs Vector3) Vector3 {
 	x := lhs.Y*rhs.Z - lhs.Z*rhs.Y
 	y := lhs.Z*rhs.X - lhs.X*rhs.Z
 	z := lhs.X*rhs.Y - lhs.Y*rhs.X
+
 	return Vec3(x, y, z)
 }
 
@@ -66,6 +71,7 @@ func (lhs Vector3) ClampScalar(min, max float64) Vector3 {
 	x := Clamp(lhs.X, min, max)
 	y := Clamp(lhs.Y, min, max)
 	z := Clamp(lhs.Z, min, max)
+
 	return Vec3(x, y, z)
 }
 
@@ -80,17 +86,20 @@ func (lhs Vector3) MaxComponent() float64 {
 func (lhs Vector3) RotateXY(angle float64) Vector3 {
 	cos := math.Cos(angle)
 	sin := math.Sin(angle)
+
 	return Vec3(lhs.X*cos-lhs.Y*sin, lhs.X*sin+lhs.Y*cos, lhs.Z)
 }
 
 func (lhs Vector3) RotateXZ(angle float64) Vector3 {
 	cos := math.Cos(angle)
 	sin := math.Sin(angle)
+
 	return Vec3(lhs.X*cos-lhs.Z*sin, lhs.Y, lhs.X*sin+lhs.Z*cos)
 }
 
 func (lhs Vector3) RotateYZ(angle float64) Vector3 {
 	cos := math.Cos(angle)
 	sin := math.Sin(angle)
+
 	return Vec3(lhs.X, lhs.Y*cos-lhs.Z*sin, lhs.Y*sin+lhs.Z*cos)
 }

internal/lm/vector4.go

@@ -18,6 +18,7 @@ func (lhs Vector4) MulScalar(rhs float64) Vector4 {
 	y := lhs.Y * rhs
 	z := lhs.Z * rhs
 	w := lhs.W * rhs
+
 	return Vec4(x, y, z, w)
 }
 
@@ -26,6 +27,7 @@ func (lhs Vector4) ClampScalar(min, max float64) Vector4 {
 	y := Clamp(lhs.Y, min, max)
 	z := Clamp(lhs.Z, min, max)
 	w := Clamp(lhs.W, min, max)
+
 	return Vec4(x, y, z, w)
 }