Grimsace/RPG_City_Maker_Reborn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

changed added basic turret support

Browse Source
This commit is contained in:
Grimsace
2026-03-02 12:50:57 -06:00
parent 8a1f05ba6b
commit 9bc97b9f4d
4 changed files with 460 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files
fortifications.go
+354
View File
@@ -12,6 +12,10 @@ const (
minWallWidthPercent = minBuildingSizePercent
maxWallWidthPercent = maxBuildingSizePercent
wallWidthPercentStep = buildingSizePercentStep
minTurretSizePercent = 0.2
maxTurretSizePercent = maxWallWidthPercent
turretSizePercentStep = 0.1
)
func clampWallWidthPercent(v float64) float64 {
@@ -56,6 +60,35 @@ func getWallWidthRangePixels(settings *Settings, width, height int) (float64, fl
return minPx, maxPx
}
func clampTurretSizePercent(v float64) float64 {
if v < minTurretSizePercent {
return minTurretSizePercent
}
if v > maxTurretSizePercent {
return maxTurretSizePercent
}
return v
}
func snapTurretSizePercent(v float64) float64 {
v = clampTurretSizePercent(v)
steps := math.Round((v - minTurretSizePercent) / turretSizePercentStep)
return clampTurretSizePercent(minTurretSizePercent + steps*turretSizePercentStep)
}
func getTurretSizePixels(settings *Settings, width, height int) float64 {
sizePercent := snapTurretSizePercent(settings.TurretSize)
avgDim := averageImageDimension(width, height)
if avgDim < 1 {
avgDim = 1
}
sizePx := (sizePercent / 100.0) * avgDim
if sizePx < 1 {
sizePx = 1
}
return sizePx
}
type FortificationLayout struct {
Mask *PixelMask
WallIDByPixel []int
@@ -360,3 +393,324 @@ func drawWallMask(img *image.RGBA, wallMask *PixelMask) {
}
}
}
func GenerateTurrets(
img *image.RGBA,
width, height int,
settings *Settings,
layout *FortificationLayout,
waterMask, roadMask *PixelMask,
roads []*Road,
) *PixelMask {
mask := NewPixelMask(width, height)
if !settings.ShowTurrets || layout == nil || layout.Mask == nil || len(layout.WallIDByPixel) != width*height {
return mask
}
if img == nil {
img = image.NewRGBA(image.Rect(0, 0, width, height))
}
if waterMask == nil {
waterMask = NewPixelMask(width, height)
}
if roadMask == nil {
roadMask = NewPixelMask(width, height)
}
sizePx := getTurretSizePixels(settings, width, height)
radius := int(math.Round(sizePx / 2.0))
if radius < 1 {
radius = 1
}
shape := settings.TurretShape
if shape != "square" {
shape = "circular"
}
colorRed := color.RGBA{R: 220, G: 25, B: 25, A: 255}
wallPoints := make(map[int][]image.Point)
waterMeetPoints := make(map[int][]image.Point)
for y := 0; y < height; y++ {
row := y * width
for x := 0; x < width; x++ {
wid := layout.WallIDByPixel[row+x]
if wid <= 0 {
continue
}
if !isBoundaryWallPixel(x, y, layout.Mask) {
continue
}
p := image.Point{X: x, Y: y}
wallPoints[wid] = append(wallPoints[wid], p)
if touchesWater(x, y, waterMask) {
waterMeetPoints[wid] = append(waterMeetPoints[wid], p)
}
}
}
occupied := make(map[int]bool)
addTurret := func(center image.Point) {
snapped, ok := snapPointToWall(center, layout.Mask, max(3, radius*4))
if !ok {
return
}
if nearbyTurretExists(mask, snapped, max(2, radius)) {
return
}
key := snapped.Y*width + snapped.X
if occupied[key] {
return
}
occupied[key] = true
drawTurret(img, mask, snapped, radius, shape, colorRed)
}
// Base spacing turrets along each wall ring.
for wid, pts := range wallPoints {
if len(pts) == 0 {
continue
}
centroid := averagePoint(pts)
sort.Slice(pts, func(i, j int) bool {
ai := math.Atan2(float64(pts[i].Y-centroid.Y), float64(pts[i].X-centroid.X))
aj := math.Atan2(float64(pts[j].Y-centroid.Y), float64(pts[j].X-centroid.X))
return ai < aj
})
// Spacing is "distance along wall as % of wall circumference", independent of turret size.
spacingPct := clamp(settings.TurretSpacing, 0, 100)
step := int(math.Round((spacingPct / 100.0) * float64(len(pts))))
if step < 1 {
step = 1
}
if step > len(pts) {
step = len(pts)
}
for i := 0; i < len(pts); i += step {
addTurret(pts[i])
}
// Always place turrets where wall meets water.
for _, p := range waterMeetPoints[wid] {
addTurret(p)
}
}
// Gate turrets: one on each side of each road crossing, spacing = 3x road width.
for _, r := range roads {
if r == nil || len(r.Points) < 2 {
continue
}
gates := roadGateCentersForRoad(r, layout)
if len(gates) == 0 {
continue
}
for _, g := range gates {
tx, ty, ok := fortEstimateWallTangent(g, layout.Mask)
if !ok {
continue
}
offset := 1.5 * float64(max(1, r.Width))
left := image.Point{
X: int(math.Round(float64(g.X) + tx*offset)),
Y: int(math.Round(float64(g.Y) + ty*offset)),
}
right := image.Point{
X: int(math.Round(float64(g.X) - tx*offset)),
Y: int(math.Round(float64(g.Y) - ty*offset)),
}
addTurret(left)
addTurret(right)
}
}
return mask
}
func isBoundaryWallPixel(x, y int, wallMask *PixelMask) bool {
if wallMask == nil || !wallMask.GetXY(x, y) {
return false
}
for dy := -1; dy <= 1; dy++ {
for dx := -1; dx <= 1; dx++ {
if dx == 0 && dy == 0 {
continue
}
nx, ny := x+dx, y+dy
if !wallMask.InBounds(nx, ny) || !wallMask.GetXY(nx, ny) {
return true
}
}
}
return false
}
func touchesWater(x, y int, waterMask *PixelMask) bool {
if waterMask == nil {
return false
}
for dy := -1; dy <= 1; dy++ {
for dx := -1; dx <= 1; dx++ {
nx, ny := x+dx, y+dy
if waterMask.GetXY(nx, ny) {
return true
}
}
}
return false
}
func averagePoint(points []image.Point) image.Point {
if len(points) == 0 {
return image.Point{}
}
var sx, sy int
for _, p := range points {
sx += p.X
sy += p.Y
}
return image.Point{X: sx / len(points), Y: sy / len(points)}
}
func drawTurret(img *image.RGBA, mask *PixelMask, center image.Point, radius int, shape string, col color.RGBA) {
for dy := -radius; dy <= radius; dy++ {
for dx := -radius; dx <= radius; dx++ {
if shape == "circular" && dx*dx+dy*dy > radius*radius {
continue
}
x, y := center.X+dx, center.Y+dy
if !mask.InBounds(x, y) {
continue
}
mask.SetXY(x, y)
img.Set(x, y, col)
}
}
}
func nearbyTurretExists(mask *PixelMask, center image.Point, radius int) bool {
if mask == nil {
return false
}
for dy := -radius; dy <= radius; dy++ {
for dx := -radius; dx <= radius; dx++ {
if dx*dx+dy*dy > radius*radius {
continue
}
if mask.GetXY(center.X+dx, center.Y+dy) {
return true
}
}
}
return false
}
func snapPointToWall(center image.Point, wallMask *PixelMask, maxRadius int) (image.Point, bool) {
if wallMask == nil {
return image.Point{}, false
}
if wallMask.GetXY(center.X, center.Y) {
return center, true
}
if maxRadius < 1 {
maxRadius = 1
}
best := image.Point{}
bestD2 := math.MaxInt
found := false
for r := 1; r <= maxRadius; r++ {
minX := center.X - r
maxX := center.X + r
minY := center.Y - r
maxY := center.Y + r
for y := minY; y <= maxY; y++ {
for x := minX; x <= maxX; x++ {
if x != minX && x != maxX && y != minY && y != maxY {
continue
}
if !wallMask.GetXY(x, y) {
continue
}
dx := x - center.X
dy := y - center.Y
d2 := dx*dx + dy*dy
if d2 < bestD2 {
bestD2 = d2
best = image.Point{X: x, Y: y}
found = true
}
}
}
if found {
return best, true
}
}
return image.Point{}, false
}
func roadGateCentersForRoad(r *Road, layout *FortificationLayout) []image.Point {
out := make([]image.Point, 0, 2)
if r == nil || layout == nil || layout.Mask == nil || len(r.Points) < 2 {
return out
}
prevID := 0
if layout.Mask.InBounds(r.Points[0].Point.X, r.Points[0].Point.Y) {
prevID = layout.WallIDByPixel[r.Points[0].Point.Y*layout.Mask.Width+r.Points[0].Point.X]
}
for i := 1; i < len(r.Points); i++ {
p := r.Points[i].Point
currID := 0
if layout.Mask.InBounds(p.X, p.Y) {
currID = layout.WallIDByPixel[p.Y*layout.Mask.Width+p.X]
}
if (prevID == 0 && currID > 0) || (prevID > 0 && currID == 0) {
out = append(out, p)
}
prevID = currID
}
return out
}
func fortEstimateWallTangent(mid image.Point, wallMask *PixelMask) (float64, float64, bool) {
if wallMask == nil {
return 0, 0, false
}
const r = 4
var pts [][2]float64
for dy := -r; dy <= r; dy++ {
y := mid.Y + dy
if y < 0 || y >= wallMask.Height {
continue
}
for dx := -r; dx <= r; dx++ {
x := mid.X + dx
if x < 0 || x >= wallMask.Width {
continue
}
if wallMask.GetXY(x, y) {
pts = append(pts, [2]float64{float64(x), float64(y)})
}
}
}
if len(pts) < 3 {
return 0, 0, false
}
var mx, my float64
for _, p := range pts {
mx += p[0]
my += p[1]
}
mx /= float64(len(pts))
my /= float64(len(pts))
var sxx, syy, sxy float64
for _, p := range pts {
dx := p[0] - mx
dy := p[1] - my
sxx += dx * dx
syy += dy * dy
sxy += dx * dy
}
if sxx+syy < 0.001 {
return 0, 0, false
}
theta := 0.5 * math.Atan2(2*sxy, sxx-syy)
return math.Cos(theta), math.Sin(theta), true
}
main.go
+75 -8
View File
@@ -96,6 +96,7 @@ func main() {
var bridgeMask *PixelMask
var exitRoadMask *PixelMask
var wallMask *PixelMask
var turretMask *PixelMask
// Set up application configuration directory
configDir, err := os.UserConfigDir()
@@ -282,29 +283,34 @@ func main() {
// Step 6: Generating Roads
var roadAnchors []image.Point
var roadList []*Road
roadBase := cloneToRGBA(finalImage, settings.Width, settings.Height)
if out, ok := runWithTimeout(generationStepTimeout, func() struct {
rd *PixelMask
br *PixelMask
ex *PixelMask
anc []image.Point
rl []*Road
} {
rd, br, ex, anc := GenerateRoadsWithPOIs(roadBase, settings.Width, settings.Height, settings, waterMask, wallLayout, roadNodes, roadTarget, edgeToEdgeOnly, seedProvider.Next())
rd, br, ex, anc, rl := GenerateRoadsWithPOIs(roadBase, settings.Width, settings.Height, settings, waterMask, wallLayout, roadNodes, roadTarget, edgeToEdgeOnly, seedProvider.Next())
return struct {
rd *PixelMask
br *PixelMask
ex *PixelMask
anc []image.Point
}{rd: rd, br: br, ex: ex, anc: anc}
rl []*Road
}{rd: rd, br: br, ex: ex, anc: anc, rl: rl}
}); ok {
roadMask, bridgeMask, exitRoadMask, roadAnchors = out.rd, out.br, out.ex, out.anc
roadMask, bridgeMask, exitRoadMask, roadAnchors, roadList = out.rd, out.br, out.ex, out.anc, out.rl
drawWallMask(roadBase, wallMask)
turretMask = GenerateTurrets(roadBase, settings.Width, settings.Height, settings, wallLayout, waterMask, roadMask, roadList)
finalImage = roadBase
} else {
log.Println("GenerateRoads timed out after 1 minute; continuing.")
roadMask = NewPixelMask(settings.Width, settings.Height)
bridgeMask = NewPixelMask(settings.Width, settings.Height)
exitRoadMask = NewPixelMask(settings.Width, settings.Height)
turretMask = NewPixelMask(settings.Width, settings.Height)
roadAnchors = nil
}
@@ -731,6 +737,59 @@ func main() {
settings.WallCurvyness = val
}))
showTurretsCheck := widget.NewCheck("Show Turrets", func(v bool) {
settings.ShowTurrets = v
})
showTurretsCheck.SetChecked(settings.ShowTurrets)
turretSizeSlider := newNumericInputSliderWithStep(minTurretSizePercent, maxTurretSizePercent, settings.TurretSize, turretSizePercentStep, "%.1f%%", "Turret Size")
turretSizeSlider.entry.OnChanged = func(s string) {
turretSizeSlider.validate(s, func(hasError bool) {
errorStates["turretSize"] = hasError
updateGenerateBtnState()
})
}
turretSizeSlider.value.AddListener(binding.NewDataListener(func() {
val, _ := turretSizeSlider.value.Get()
settings.TurretSize = val
}))
turretShapeLabel := widget.NewLabel("Turret Shape:")
turretShapeSelect := widget.NewSelect([]string{"circular", "square"}, func(s string) {
settings.TurretShape = s
})
turretShapeSelect.SetSelected(settings.TurretShape)
turretSpacingSlider := newNumericInputSlider(0, 100, settings.TurretSpacing, "%.0f%%", "Turret Spacing")
turretSpacingSlider.entry.OnChanged = func(s string) {
turretSpacingSlider.validate(s, func(hasError bool) {
errorStates["turretSpacing"] = hasError
updateGenerateBtnState()
})
}
turretSpacingSlider.value.AddListener(binding.NewDataListener(func() {
val, _ := turretSpacingSlider.value.Get()
settings.TurretSpacing = val
}))
turretControls := container.NewVBox(
turretSizeSlider,
turretShapeLabel,
turretShapeSelect,
turretSpacingSlider,
)
if !settings.ShowTurrets {
turretControls.Hide()
}
showTurretsCheck.OnChanged = func(v bool) {
settings.ShowTurrets = v
if v {
turretControls.Show()
} else {
turretControls.Hide()
}
}
// Create UI elements for error display and action buttons
errorLabel := widget.NewLabel("")
errorLabel.Wrapping = fyne.TextWrapWord
@@ -749,7 +808,7 @@ func main() {
showSaveDialog(w, bumpmapImg.Image, settings)
})
exportMasksBtn := widget.NewButton("Export Masks", func() {
showMasksSaveDialog(w, canvasImg.Image, heightmapImg.Image, bumpmapImg.Image, settings, lakes, riverMask, treeMask, roadMask, bridgeMask, wallMask, buildingMask)
showMasksSaveDialog(w, canvasImg.Image, heightmapImg.Image, bumpmapImg.Image, settings, lakes, riverMask, treeMask, roadMask, bridgeMask, wallMask, turretMask, buildingMask)
})
// Main generation button and logic
generateBtn = widget.NewButton("Generate", func() {
@@ -905,23 +964,27 @@ func main() {
progressBar.SetValue(6.0 / 13.0)
})
var roadAnchors []image.Point
var roadList []*Road
roadBase := cloneToRGBA(finalImage, settings.Width, settings.Height)
if out, ok := runWithTimeout(generationStepTimeout, func() struct {
rd *PixelMask
br *PixelMask
ex *PixelMask
anc []image.Point
rl []*Road
} {
rd, br, ex, anc := GenerateRoadsWithPOIs(roadBase, settings.Width, settings.Height, settings, waterMask, wallLayout, roadNodes, roadTarget, edgeToEdgeOnly, seedProvider.Next())
rd, br, ex, anc, rl := GenerateRoadsWithPOIs(roadBase, settings.Width, settings.Height, settings, waterMask, wallLayout, roadNodes, roadTarget, edgeToEdgeOnly, seedProvider.Next())
return struct {
rd *PixelMask
br *PixelMask
ex *PixelMask
anc []image.Point
}{rd: rd, br: br, ex: ex, anc: anc}
rl []*Road
}{rd: rd, br: br, ex: ex, anc: anc, rl: rl}
}); ok {
roadMask, bridgeMask, exitRoadMask, roadAnchors = out.rd, out.br, out.ex, out.anc
roadMask, bridgeMask, exitRoadMask, roadAnchors, roadList = out.rd, out.br, out.ex, out.anc, out.rl
drawWallMask(roadBase, wallMask)
turretMask = GenerateTurrets(roadBase, settings.Width, settings.Height, settings, wallLayout, waterMask, roadMask, roadList)
finalImage = roadBase
} else {
log.Println("GenerateRoads timed out after 1 minute; continuing.")
@@ -929,6 +992,7 @@ func main() {
roadMask = NewPixelMask(settings.Width, settings.Height)
bridgeMask = NewPixelMask(settings.Width, settings.Height)
exitRoadMask = NewPixelMask(settings.Width, settings.Height)
turretMask = NewPixelMask(settings.Width, settings.Height)
roadAnchors = nil
}
placementMask := cloneMask(roadMask)
@@ -1135,6 +1199,8 @@ func main() {
numWallsSlider,
cityCoverageSlider,
wallCurvynessSlider,
showTurretsCheck,
turretControls,
))
numBuildingsSlider := newNumericInputSlider(0, 10000, float64(settings.NumBuildings), "%.0f", "Number of Buildings")
numBuildingsSlider.entry.OnChanged = func(s string) {
@@ -1498,7 +1564,7 @@ func encodeImageToWriter(w io.Writer, img image.Image, format string) error {
}
// showMasksSaveDialog displays a dialog for saving the generated masks.
func showMasksSaveDialog(win fyne.Window, canvasImg, heightmapImg, bumpmapImg image.Image, settings *Settings, lakes [][]image.Point, riverMask, treeMask, roadMask, bridgeMask, wallMask, buildingMask *PixelMask) {
func showMasksSaveDialog(win fyne.Window, canvasImg, heightmapImg, bumpmapImg image.Image, settings *Settings, lakes [][]image.Point, riverMask, treeMask, roadMask, bridgeMask, wallMask, turretMask, buildingMask *PixelMask) {
// Create UI elements for the save dialog
fileNameEntry := widget.NewEntry()
fileNameEntry.SetPlaceHolder("masks_folder")
@@ -1583,6 +1649,7 @@ func showMasksSaveDialog(win fyne.Window, canvasImg, heightmapImg, bumpmapImg im
{name: "roads_mask." + imgFormat, make: func() image.Image { return maskToGray(roadMask) }},
{name: "bridges_mask." + imgFormat, make: func() image.Image { return maskToGray(bridgeMask) }},
{name: "walls_mask." + imgFormat, make: func() image.Image { return maskToGray(wallMask) }},
{name: "turrets_mask." + imgFormat, make: func() image.Image { return maskToGray(turretMask) }},
{name: "buildings_mask." + imgFormat, make: func() image.Image { return maskToGray(buildingMask) }},
}
roads.go
+9 -8
View File
@@ -88,7 +88,8 @@ func GenerateRoads(
waterMask *PixelMask,
seed int64,
) (*PixelMask, *PixelMask, *PixelMask, []image.Point) {
return GenerateRoadsWithPOIs(img, width, height, settings, waterMask, nil, nil, 0, false, seed)
roadMask, bridgeMask, exitRoadMask, roadAnchors, _ := GenerateRoadsWithPOIs(img, width, height, settings, waterMask, nil, nil, 0, false, seed)
return roadMask, bridgeMask, exitRoadMask, roadAnchors
}
func PrepareRoadNodes(width, height int, settings *Settings, waterMask *PixelMask, seed int64) ([]*PointOfInterest, int, bool) {
@@ -122,7 +123,7 @@ func GenerateRoadsWithPOIs(
roadTarget int,
edgeToEdgeOnly bool,
seed int64,
) (*PixelMask, *PixelMask, *PixelMask, []image.Point) {
) (*PixelMask, *PixelMask, *PixelMask, []image.Point, []*Road) {
if img == nil {
img = image.NewRGBA(image.Rect(0, 0, width, height))
}
@@ -139,7 +140,7 @@ func GenerateRoadsWithPOIs(
internalRoads := int(math.Round(clamp(settings.RoadDistribution, 0, 100)))
exitRoads := max(0, settings.RoadExits)
if internalRoads == 0 && exitRoads == 0 {
return NewPixelMask(width, height), NewPixelMask(width, height), NewPixelMask(width, height), nil
return NewPixelMask(width, height), NewPixelMask(width, height), NewPixelMask(width, height), nil, nil
}
if internalRoads > 0 {
roadTarget = internalRoads
@@ -159,22 +160,22 @@ func GenerateRoadsWithPOIs(
pois = generatePOIs(width, height, settings, waterMask, randSrc, roadTarget)
}
if len(pois) < 2 {
return NewPixelMask(width, height), NewPixelMask(width, height), NewPixelMask(width, height), nil
return NewPixelMask(width, height), NewPixelMask(width, height), NewPixelMask(width, height), nil, nil
}
roads = connectPOIs(pois, width, height, settings, randSrc, waterMask, wallLayout, roadTarget)
roads = appendExitRoads(roads, pois, width, height, settings, randSrc, waterMask, wallLayout)
}
if len(roads) == 0 {
return NewPixelMask(width, height), NewPixelMask(width, height), NewPixelMask(width, height), nil
return NewPixelMask(width, height), NewPixelMask(width, height), NewPixelMask(width, height), nil, nil
}
roads = applyWallCrossingRules(roads, wallLayout, waterMask, randSrc)
if len(roads) == 0 {
return NewPixelMask(width, height), NewPixelMask(width, height), NewPixelMask(width, height), nil
return NewPixelMask(width, height), NewPixelMask(width, height), NewPixelMask(width, height), nil, nil
}
roads = reduceRepeatedBridges(roads, waterMask, width, height, randSrc)
if len(roads) == 0 {
return NewPixelMask(width, height), NewPixelMask(width, height), NewPixelMask(width, height), nil
return NewPixelMask(width, height), NewPixelMask(width, height), NewPixelMask(width, height), nil, nil
}
roads = ensureRoadNetworkConnected(roads, settings, randSrc, waterMask, wallLayout, width, height)
assignRoadWidths(roads, settings, randSrc, width, height, wallLayout)
@@ -190,7 +191,7 @@ func GenerateRoadsWithPOIs(
}
roadAnchors := roadMask.ToPoints()
return roadMask, bridgeMask, exitRoadMask, roadAnchors
return roadMask, bridgeMask, exitRoadMask, roadAnchors, roads
}
func nudgePOIsOutsideWalls(pois []*PointOfInterest, wallMask, waterMask *PixelMask, settings *Settings, width, height int, randSrc *rand.Rand) {
settings.go
+22
View File
@@ -50,6 +50,10 @@ type Settings struct {
NumWalls int `json:"num_walls"`
CityCoverage float64 `json:"city_coverage"`
WallCurvyness float64 `json:"wall_curvyness"`
ShowTurrets bool `json:"show_turrets"`
TurretSize float64 `json:"turret_size"`
TurretShape string `json:"turret_shape"`
TurretSpacing float64 `json:"turret_spacing"`
// Building settings
NumBuildings int `json:"num_buildings"`
@@ -151,6 +155,10 @@ func LoadSettings() (*Settings, error) {
NumWalls: 1,
CityCoverage: 70,
WallCurvyness: 35,
ShowTurrets: true,
TurretSize: 0.6,
TurretShape: "circular",
TurretSpacing: 55,
NumBuildings: 200,
MinBuildingSize: 3.5,
MaxBuildingSize: 10.0,
@@ -230,6 +238,18 @@ func LoadSettings() (*Settings, error) {
if _, ok := rawKeys["wall_curvyness"]; !ok {
settings.WallCurvyness = 35
}
if _, ok := rawKeys["show_turrets"]; !ok {
settings.ShowTurrets = true
}
if _, ok := rawKeys["turret_size"]; !ok {
settings.TurretSize = 0.6
}
if _, ok := rawKeys["turret_shape"]; !ok || (settings.TurretShape != "square" && settings.TurretShape != "circular") {
settings.TurretShape = "circular"
}
if _, ok := rawKeys["turret_spacing"]; !ok {
settings.TurretSpacing = 55
}
// Wall widths are percentages of average image dimension.
// Migrate older pixel-based values when they exceed the valid percentage range.
@@ -250,6 +270,8 @@ func LoadSettings() (*Settings, error) {
}
settings.CityCoverage = clamp(settings.CityCoverage, 1, 100)
settings.WallCurvyness = clamp(settings.WallCurvyness, 0, 100)
settings.TurretSize = snapTurretSizePercent(settings.TurretSize)
settings.TurretSpacing = clamp(settings.TurretSpacing, 0, 100)
// Tree sizes are percentages of average image dimension.
// Migrate older pixel-based values when they exceed the valid percentage range.