dragonfly: add gocritic to golangci-lint config (df-mc#1245)

* feat(dragonfly): add gocritic to golangci-lint

* various changes

---------

Co-authored-by: هـ <104190360+didntpot@users.noreply.github.com>

Author: RestartFU

.gitignore

@@ -1,5 +1,7 @@
-# JetBrains
+# IDEs
 .idea/
+.zed/
+.vscode/
 
 # Dragonfly
 /world/

.golangci.yml

@@ -2,7 +2,7 @@ version: "2"
 
 linters:
   default: none
-  enable: [govet, staticcheck, ineffassign]
+  enable: [govet, staticcheck, ineffassign, gocritic]
   settings:
     staticcheck:
       checks: [all, -ST1000, -ST1003, -ST1016]

server/block/cube/trace/trace.go

@@ -30,19 +30,20 @@ func TraverseBlocks(start, end mgl64.Vec3, f func(pos cube.Pos) (con bool)) {
 			return
 		}
 
-		if max[0] < max[1] && max[0] < max[2] {
+		switch {
+		case max[0] < max[1] && max[0] < max[2]:
 			if max[0] > r {
 				return
 			}
 			b[0] += stepX
 			max[0] += delta[0]
-		} else if max[1] < max[2] {
+		case max[1] < max[2]:
 			if max[1] > r {
 				return
 			}
 			b[1] += stepY
 			max[1] += delta[1]
-		} else {
+		default:
 			if max[2] > r {
 				return
 			}

server/block/smelter.go

@@ -221,7 +221,8 @@ func (s *smelter) tickSmelting(requirement, decrement time.Duration, lit bool, s
 		s.remainingDuration -= time.Millisecond * 50
 
 		// If we have a valid smeltable item, process a single stage of smelting.
-		if canSmelt {
+		switch {
+		case canSmelt:
 			// Increase the cook duration by a tick.
 			s.cookDuration += time.Millisecond * 50
 
@@ -243,10 +244,10 @@ func (s *smelter) tickSmelting(requirement, decrement time.Duration, lit bool, s
 				s.cookDuration -= requirement
 				s.experience += int(earned)
 			}
-		} else if s.remainingDuration == 0 {
+		case s.remainingDuration == 0:
 			// We've run out of fuel, so we need to reset the max duration too.
 			s.maxDuration = 0
-		} else {
+		default:
 			// We still have some remaining fuel, but the input isn't smeltable, so we reset the cook duration.
 			s.cookDuration = 0
 		}

server/block/wall.go

@@ -224,13 +224,15 @@ func (w Wall) calculatePost(tx *world.Tx, pos cube.Pos) (Wall, bool) {
 	}
 	if !post {
 		// If a wall has two connections that are in different axis then it becomes a post regardless of the above block.
-		post = connections < 2
-		if connections >= 2 {
-			if w.NorthConnection != NoWallConnection() && w.SouthConnection != NoWallConnection() {
+		if connections < 2 {
+			post = true
+		} else {
+			switch {
+			case w.NorthConnection != NoWallConnection() && w.SouthConnection != NoWallConnection():
 				post = w.EastConnection != NoWallConnection() || w.WestConnection != NoWallConnection()
-			} else if w.EastConnection != NoWallConnection() && w.WestConnection != NoWallConnection() {
+			case w.EastConnection != NoWallConnection() && w.WestConnection != NoWallConnection():
 				post = w.NorthConnection != NoWallConnection() || w.SouthConnection != NoWallConnection()
-			} else {
+			default:
 				post = true
 			}
 		}

server/entity/experience.go

@@ -76,11 +76,13 @@ func (e *ExperienceManager) Reset() {
 // progressFromExperience returns the level and progress from the total experience given.
 func progressFromExperience(experience float64) (level int, progress float64) {
 	var a, b, c float64
-	if experience <= float64(experienceForLevels(16)) {
+
+	switch {
+	case experience <= float64(experienceForLevels(16)):
 		a, b = 1.0, 6.0
-	} else if experience <= float64(experienceForLevels(31)) {
+	case experience <= float64(experienceForLevels(31)):
 		a, b, c = 2.5, -40.5, 360.0
-	} else {
+	default:
 		a, b, c = 4.5, -162.5, 2220.0
 	}
 

server/item/book_and_quill.go

@@ -81,9 +81,7 @@ func (b BookAndQuill) SwapPages(pageOne, pageTwo int) BookAndQuill {
 	if _, ok := b.Page(max(pageOne, pageTwo)); !ok {
 		panic("invalid page number")
 	}
-	temp := b.Pages[pageOne]
-	b.Pages[pageOne] = b.Pages[pageTwo]
-	b.Pages[pageTwo] = temp
+	b.Pages[pageOne], b.Pages[pageTwo] = b.Pages[pageTwo], b.Pages[pageOne]
 	return b
 }
 

server/item/inventory/inventory.go

@@ -302,7 +302,9 @@ func (inv *Inventory) Merge(inv2 *Inventory, f func(int, item.Stack, item.Stack)
 	defer inv2.mu.RUnlock()
 
 	n := New(len(inv.slots)+len(inv2.slots), f)
-	n.slots = append(inv.slots, inv2.slots...)
+	n.slots = make([]item.Stack, 0, len(inv.slots)+len(inv2.slots))
+	n.slots = append(n.slots, inv.slots...)
+	n.slots = append(n.slots, inv2.slots...)
 	return n
 }
 

server/player/player.go

@@ -537,14 +537,15 @@ func (p *Player) Heal(health float64, source world.HealingSource) {
 
 // updateFallState is called to update the entities falling state.
 func (p *Player) updateFallState(distanceThisTick float64) {
-	if p.OnGround() {
+	switch {
+	case p.OnGround():
 		if p.fallDistance > 0 {
 			p.fall(p.fallDistance)
 			p.ResetFallDistance()
 		}
-	} else if distanceThisTick < p.fallDistance {
+	case distanceThisTick < p.fallDistance:
 		p.fallDistance -= distanceThisTick
-	} else {
+	default:
 		p.ResetFallDistance()
 	}
 }
@@ -588,7 +589,7 @@ func (p *Player) Hurt(dmg float64, src world.DamageSource) (float64, bool) {
 
 	immune := time.Now().Before(p.immuneUntil)
 	if immune {
-		if damageLeft = damageLeft - p.lastDamage; damageLeft <= 0 {
+		if damageLeft -= p.lastDamage; damageLeft <= 0 {
 			return 0, false
 		}
 	}

server/player/playerdb/effect.go

@@ -30,11 +30,12 @@ func dataToEffects(data []jsonEffect) []effect.Effect {
 		}
 		switch eff := e.(type) {
 		case effect.LastingType:
-			if d.Ambient {
+			switch {
+			case d.Ambient:
 				effects[i] = effect.NewAmbient(eff, d.Level, d.Duration)
-			} else if d.Infinite {
+			case d.Infinite:
 				effects[i] = effect.NewInfinite(eff, d.Level)
-			} else {
+			default:
 				effects[i] = effect.New(eff, d.Level, d.Duration)
 			}