diff --git a/terrain.go b/terrain.go index 29188de..13bb0f3 100644 --- a/terrain.go +++ b/terrain.go @@ -1,6 +1,7 @@ package main import ( + "container/heap" "image" "image/color" "image/draw" @@ -11,91 +12,142 @@ import ( "github.com/aquilax/go-perlin" ) +// lakePixel represents a potential pixel to be added to a lake during growth +type lakePixel struct { + point image.Point + score float64 + index int // required for heap.Interface +} + +type priorityQueue []*lakePixel + +func (pq priorityQueue) Len() int { return len(pq) } +func (pq priorityQueue) Less(i, j int) bool { return pq[i].score > pq[j].score } // Max-heap +func (pq priorityQueue) Swap(i, j int) { + pq[i], pq[j] = pq[j], pq[i] + pq[i].index = i + pq[j].index = j +} +func (pq *priorityQueue) Push(x interface{}) { + n := len(*pq) + item := x.(*lakePixel) + item.index = n + *pq = append(*pq, item) +} +func (pq *priorityQueue) Pop() interface{} { + old := *pq + n := len(old) + item := old[n-1] + old[n-1] = nil + item.index = -1 + *pq = old[0 : n-1] + return item +} + +// GenerateLakes creates a specific number of lakes, each covering a specific percentage of the total image area. +// It uses a priority-based growth algorithm to ensure each lake is a single continuous component with organic edges. 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) + + // Global map to track which pixels are already water to prevent duplicate darkening + isWater := make(map[image.Point]bool) var allLakePixels []image.Point - if numLakes == 0 { + if numLakes <= 0 || lakeSize <= 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))) + totalArea := float64(width * height) + targetPixelsPerLake := int(math.Round(totalArea * (lakeSize / 100.0))) + if targetPixelsPerLake <= 0 { + targetPixelsPerLake = 1 + } + + r := rand.New(rand.NewSource(time.Now().UnixNano())) + // One octave for maximum smoothness (no fractal detail that creates islands) + p := perlin.NewPerlin(2.0, 2.0, 1, r.Int63()) 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}) + // Unique seed for this specific lake + seedX := r.Float64() * 10000.0 + seedY := r.Float64() * 10000.0 + + // Choose a random seed point + startPt := image.Point{X: r.Intn(width), Y: r.Intn(height)} + + pq := &priorityQueue{} + heap.Init(pq) + + // track pixels already considered for THIS lake + visited := make(map[image.Point]bool) + + // Scale noise relative to expected lake size to maintain look + radius := math.Sqrt(float64(targetPixelsPerLake) / math.Pi) + // Much lower frequency to avoid islands and thin peninsulas + noiseFreq := 0.01 + (0.2 / (radius + 1.0)) + + // Helper to calculate score + getScore := func(pt image.Point) float64 { + dx, dy := pt.X-startPt.X, pt.Y-startPt.Y + dist := math.Sqrt(float64(dx*dx + dy*dy)) + + // Noise component + noise := p.Noise2D(seedX+float64(dx)*noiseFreq, seedY+float64(dy)*noiseFreq) + + // Non-linear distance penalty: very low near center, increases rapidly at edge + // This makes the center much more "solid" + distPenalty := math.Pow(dist/radius, 2.0) + + return noise - distPenalty + } + + // Push starting point + heap.Push(pq, &lakePixel{point: startPt, score: getScore(startPt)}) + visited[startPt] = true + + lakeCount := 0 + for pq.Len() > 0 && lakeCount < targetPixelsPerLake { + // Pop the highest scoring frontier pixel + current := heap.Pop(pq).(*lakePixel) + + // Add to canvas and global list + canvas.Set(current.point.X, current.point.Y, color.RGBA{R: 0, G: 0, B: 255, A: 255}) + if !isWater[current.point] { + isWater[current.point] = true + allLakePixels = append(allLakePixels, current.point) } - } + lakeCount++ - // 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) - } + // Add neighbors to frontier + for dy := -1; dy <= 1; dy++ { + for dx := -1; dx <= 1; dx++ { + if dx == 0 && dy == 0 { + continue + } + neighbor := image.Point{X: current.point.X + dx, Y: current.point.Y + dy} - 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 + // Bounds check + if neighbor.X < 0 || neighbor.X >= width || neighbor.Y < 0 || neighbor.Y >= height { + continue + } - 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 - } + if !visited[neighbor] { + visited[neighbor] = true + heap.Push(pq, &lakePixel{ + point: neighbor, + score: getScore(neighbor), + }) } } } } - - // 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 } +// DarkenLakeAreas applies a visual darkening effect to the heightmap where lakes exist. func DarkenLakeAreas(heightmap image.Image, lakePixels []image.Point) image.Image { bounds := heightmap.Bounds() composite := image.NewRGBA(bounds)