initial commit, with support for basic lake generation.

2026-01-26 14:29:05 -06:00
commit b2db760502
6 changed files with 510 additions and 0 deletions
@@ -0,0 +1,115 @@
+package main
+
+import (
+	"image"
+	"image/color"
+	"image/draw"
+	"math"
+	"math/rand"
+	"time"
+
+	"github.com/aquilax/go-perlin"
+)
+
+func GenerateLakes(width, height, numLakes int, lakeSize float64) (image.Image, []image.Point) {
+	canvas := image.NewRGBA(image.Rect(0, 0, width, height))
+	draw.Draw(canvas, canvas.Bounds(), image.NewUniform(color.White), image.Point{}, draw.Src)
+	var allLakePixels []image.Point
+
+	if numLakes == 0 {
+		return canvas, allLakePixels
+	}
+
+	p := perlin.NewPerlin(2, 2, 5, rand.New(rand.NewSource(time.Now().UnixNano())).Int63())
+	blobSize := int(math.Sqrt(float64(width*height) * (lakeSize / 100.0)))
+
+	for i := 0; i < numLakes; i++ {
+		// Create a noise map for the lake
+		noiseMap := image.NewGray(image.Rect(0, 0, blobSize*2, blobSize*2))
+		for x := 0; x < blobSize*2; x++ {
+			for y := 0; y < blobSize*2; y++ {
+				noise := p.Noise2D(float64(x)/float64(blobSize), float64(y)/float64(blobSize))
+				grayColor := uint8((noise + 1) * 127.5)
+				noiseMap.SetGray(x, y, color.Gray{Y: grayColor})
+			}
+		}
+
+		// Find the largest contiguous area in the noise map
+		var largestLake []*image.Point
+		visited := make([][]bool, blobSize*2)
+		for i := range visited {
+			visited[i] = make([]bool, blobSize*2)
+		}
+
+		for x := 0; x < blobSize*2; x++ {
+			for y := 0; y < blobSize*2; y++ {
+				if !visited[x][y] {
+					c := noiseMap.At(x, y)
+					r, _, _, _ := c.RGBA()
+					if r < 32768 {
+						var currentLake []*image.Point
+						q := []*image.Point{{X: x, Y: y}}
+						visited[x][y] = true
+
+						for len(q) > 0 {
+							p := q[0]
+							q = q[1:]
+							currentLake = append(currentLake, p)
+
+							for dx := -1; dx <= 1; dx++ {
+								for dy := -1; dy <= 1; dy++ {
+									if dx == 0 && dy == 0 {
+										continue
+									}
+									nx, ny := p.X+dx, p.Y+dy
+									if nx >= 0 && nx < blobSize*2 && ny >= 0 && ny < blobSize*2 && !visited[nx][ny] {
+										c := noiseMap.At(nx, ny)
+										r, _, _, _ := c.RGBA()
+										if r < 32768 {
+											visited[nx][ny] = true
+											q = append(q, &image.Point{X: nx, Y: ny})
+										}
+									}
+								}
+							}
+						}
+						if len(currentLake) > len(largestLake) {
+							largestLake = currentLake
+						}
+					}
+				}
+			}
+		}
+
+		// Draw the largest lake on the canvas
+		lakeX := rand.Intn(width)
+		lakeY := rand.Intn(height)
+		for _, p := range largestLake {
+			nx, ny := lakeX+p.X-blobSize, lakeY+p.Y-blobSize
+			if nx >= 0 && nx < width && ny >= 0 && ny < height {
+				canvas.Set(nx, ny, color.RGBA{R: 0, G: 0, B: 255, A: 255})
+				allLakePixels = append(allLakePixels, image.Point{X: nx, Y: ny})
+			}
+		}
+	}
+
+	return canvas, allLakePixels
+}
+
+func DarkenLakeAreas(heightmap image.Image, lakePixels []image.Point) image.Image {
+	bounds := heightmap.Bounds()
+	composite := image.NewRGBA(bounds)
+	draw.Draw(composite, bounds, heightmap, image.Point{}, draw.Src)
+
+	for _, p := range lakePixels {
+		c := composite.At(p.X, p.Y)
+		r, g, b, a := c.RGBA()
+		// Darken by 15%
+		r = uint32(float64(r) * 0.85)
+		g = uint32(float64(g) * 0.85)
+		b = uint32(float64(b) * 0.85)
+		composite.Set(p.X, p.Y, color.RGBA64{R: uint16(r), G: uint16(g), B: uint16(b), A: uint16(a)})
+	}
+
+	return composite
+}