// Package cantiere is a Sinopia showcase engine: isometric maquettes of
// imaginary hill towns on a ruled drafting sheet, with red scaffolding for
// the storeys not yet built ("cantiere" is Italian for building site).
//
// A plan generator writes an N x N height map (N = 6..8); columns are drawn
// back to front, one anti-diagonal at a time. Columns on one diagonal never
// overlap, so each diagonal is a handful of merged paths, one per fill, and
// windows are skewed tiles instead of one element per window. That
// keeps the SVG small (median ~5.5 KB) and the render cheap.
//
// Determinism: the same FNV-1a + splitmix64 stream as Genesis, with separate
// streams for traits (seed+"|traits") and art (seed+"|art"), so art draws
// never shift traits. Pure integer math; every division truncates (Go). The
// TypeScript twin (frontend/src/engines/cantiere.ts) is byte-identical; the
// golden vectors in cantiere_test.gno pin both.
//
// Params ("" = the showcase): canonical JSON in schema order, e.g.
// {"light":"Night","material":"Any","plan":"Any","scaffold":true}. A param
// pins one trait after all trait draws, so the other traits of a seed stay
// the same in every variant.
package cantiere
import (
"errors"
"strconv"
"strings"
"gno.land/p/g1jz6j9hj6rdf5ltl2kcrpa4jwtdh3w30z0yul06/sinopia/engine/v1"
)
// traitTypes in the order Traits returns them.
var traitTypes = []string{"Plan", "Material", "Light", "Scaffold", "Openings", "Garden", "Water", "Storeys", "Rarity"}
// MaxSVGBytes: the largest output measured is 15,448 B (5,000 default seeds)
// and 15,174 B (19,600 renders over every param set); median ~5.5 KB. 2x margin.
const MaxSVGBytes = 32768
// ParamsSchema is the Studio form: three trait pins and a scaffolding switch.
const ParamsSchema = `{"type":"object","properties":{` +
`"light":{"type":"string","title":"Light","enum":["Any","Morning","Evening","Noon","Night"],"default":"Any"},` +
`"material":{"type":"string","title":"Material","enum":["Any","Tufa","Brick","Travertine","Painted Plaster","Concrete","Basalt"],"default":"Any"},` +
`"plan":{"type":"string","title":"Plan","enum":["Any","Hill Town","Ziggurat","Courtyard","Terraces","Towers","Ruin"],"default":"Any"},` +
`"scaffold":{"type":"boolean","title":"Scaffolding","default":true}}}`
// Manifest describes the engine. Author and FeeBps are set by the adapter
// realm that registers it.
func Manifest() engine.Manifest {
return engine.Manifest{
Name: "Cantiere",
Version: "1.0.0",
Description: "Isometric maquettes of imaginary hill towns on a ruled drafting sheet, " +
"with red scaffolding for the storeys not yet built.",
License: "TBD",
ParamsSchema: ParamsSchema,
TraitTypes: append([]string{}, traitTypes...),
Living: false,
MaxSVGBytes: MaxSVGBytes,
}
}
// ValidateParams accepts "" or exactly the canonical params JSON.
func ValidateParams(params string) error {
_, err := ParseParams(params)
return err
}
// Traits returns the nine traits of in.Seed in TraitTypes order. It never
// renders: a few table draws only.
func Traits(in engine.Input) []engine.Trait {
t := TraitsOf(in.Seed, in.Params)
return []engine.Trait{
{Type: "Plan", Value: t.Plan},
{Type: "Material", Value: t.Material},
{Type: "Light", Value: t.Light},
{Type: "Scaffold", Value: t.Scaffold},
{Type: "Openings", Value: t.Openings},
{Type: "Garden", Value: t.Garden},
{Type: "Water", Value: t.Water},
{Type: "Storeys", Value: strconv.Itoa(t.Storeys)},
{Type: "Rarity", Value: t.Rarity},
}
}
// Render returns the raw SVG for in.Seed and in.Params.
func Render(in engine.Input) string { return SVG(in.Seed, in.Params) }
// ---------------------------------------------------------------------------
// Params
// ---------------------------------------------------------------------------
const anyValue = "Any"
var (
paramLights = []string{anyValue, "Morning", "Evening", "Noon", "Night"}
paramMaterials = []string{anyValue, "Tufa", "Brick", "Travertine", "Painted Plaster", "Concrete", "Basalt"}
paramPlans = []string{anyValue, "Hill Town", "Ziggurat", "Courtyard", "Terraces", "Towers", "Ruin"}
)
// Params are the decoded collection params.
type Params struct {
Light, Material, Plan string
Scaffold bool
}
var errParams = errors.New(`cantiere params: want "" or {"light":"…","material":"…","plan":"…","scaffold":true|false} with values from the schema`)
type paramReader struct {
s string
i int
}
func (q *paramReader) lit(l string) bool {
if !strings.HasPrefix(q.s[q.i:], l) {
return false
}
q.i += len(l)
return true
}
func (q *paramReader) str(allowed []string) (string, bool) {
end := strings.IndexByte(q.s[q.i:], '"')
if end < 0 {
return "", false
}
v := q.s[q.i : q.i+end]
q.i += end + 1
for _, a := range allowed {
if a == v {
return v, true
}
}
return "", false
}
// ParseParams decodes "" (defaults) or the canonical JSON Studio sends
// (schema order, no whitespace). Anything else is an error.
func ParseParams(s string) (Params, error) {
p := Params{Light: anyValue, Material: anyValue, Plan: anyValue, Scaffold: true}
if s == "" {
return p, nil
}
q := ¶mReader{s: s}
var ok bool
if !q.lit(`{"light":"`) {
return p, errParams
}
if p.Light, ok = q.str(paramLights); !ok || !q.lit(`,"material":"`) {
return p, errParams
}
if p.Material, ok = q.str(paramMaterials); !ok || !q.lit(`,"plan":"`) {
return p, errParams
}
if p.Plan, ok = q.str(paramPlans); !ok || !q.lit(`,"scaffold":`) {
return p, errParams
}
switch {
case q.lit("true"):
p.Scaffold = true
case q.lit("false"):
p.Scaffold = false
default:
return p, errParams
}
if !q.lit("}") || q.i != len(s) {
return p, errParams
}
return p, nil
}
func mustParams(s string) Params {
p, err := ParseParams(s)
if err != nil {
panic(err.Error())
}
return p
}
// ---------------------------------------------------------------------------
// Deterministic randomness: FNV-1a over the seed, then splitmix64 (Genesis).
// ---------------------------------------------------------------------------
const (
fnvOffset uint64 = 14695981039346656037
fnvPrime uint64 = 1099511628211
)
type rng struct {
state uint64
}
func newRNG(seed string) *rng {
h := fnvOffset
for i := 0; i < len(seed); i++ {
h ^= uint64(seed[i])
h *= fnvPrime
}
if h == 0 {
h = fnvPrime
}
return &rng{state: h}
}
func (r *rng) next() uint64 {
r.state += 0x9E3779B97F4A7C15
z := r.state
z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9
z = (z ^ (z >> 27)) * 0x94D049BB133111EB
return z ^ (z >> 31)
}
// intn returns a value in [0, n).
func (r *rng) intn(n int) int {
if n <= 0 {
return 0
}
return int(r.next() % uint64(n))
}
// rangeIn returns a value in [lo, hi].
func (r *rng) rangeIn(lo, hi int) int { return lo + r.intn(hi-lo+1) }
// ---------------------------------------------------------------------------
// Trait tables: weights sum to 100; score feeds the rarity tier.
// ---------------------------------------------------------------------------
type option struct {
name string
weight int
score int
}
// weightTotal: every table's weights sum to 100 (TestTableWeights), so one
// draw of intn(100) walks the table; the TS twin sums them, same value.
const weightTotal = 100
// pickIdx returns the index of the drawn option.
func pickIdx(r *rng, table []option) int {
roll := r.intn(weightTotal)
acc := 0
for k := 0; k < len(table); k++ {
acc += table[k].weight
if roll < acc {
return k
}
}
return len(table) - 1
}
func findIdx(table []option, name string) int {
for k := 0; k < len(table); k++ {
if table[k].name == name {
return k
}
}
return 0
}
var (
plans = []option{{"Hill Town", 26, 0}, {"Ziggurat", 18, 1}, {"Courtyard", 18, 1}, {"Terraces", 16, 1}, {"Towers", 14, 1}, {"Ruin", 8, 3}}
materials = []option{{"Tufa", 22, 0}, {"Brick", 20, 0}, {"Travertine", 18, 0}, {"Painted Plaster", 18, 1}, {"Concrete", 12, 1}, {"Basalt", 10, 2}}
lights = []option{{"Morning", 34, 0}, {"Evening", 34, 0}, {"Noon", 18, 1}, {"Night", 14, 3}}
scaffolds = []option{{"None", 40, 0}, {"Some", 40, 0}, {"Heavy", 20, 2}}
openingsT = []option{{"Windows", 55, 0}, {"Loggias", 25, 1}, {"Blind", 20, 1}}
gardens = []option{{"None", 55, 0}, {"Cypresses", 32, 1}, {"Roof Gardens", 13, 2}}
waters = []option{{"None", 55, 0}, {"Pool", 25, 1}, {"Canal", 20, 1}}
)
// materialColours in materials order; Painted Plaster picks one per column.
var materialColours = [][]string{
{"#d9b46a"},
{"#b3563a"},
{"#e6dcc6"},
{"#e8a06a", "#e9c46a", "#d9786a", "#c9b48a", "#9ab08a", "#e6d2b0"},
{"#a9a59c"},
{"#5a5650"},
}
// Tier cut-offs on the summed scores (Storeys is derived, not scored). Over
// 1,000 sample seeds: Common 25% / Uncommon 39% / Rare 26% / Legendary 9% /
// Mythic 1%.
const (
scoreMythic = 9
scoreLegendary = 7
scoreRare = 5
scoreUncommon = 3
)
// TraitSet is the decoded properties of a seed; the SVG and the trait list
// both read it, so picture and metadata cannot disagree.
type TraitSet struct {
Plan, Material, Light, Scaffold, Openings, Garden, Water string
Storeys int // tallest built column
Score int
Rarity string
material int // index into materials
}
func derive(seed string, p Params) TraitSet {
r := newRNG(seed + "|traits")
// Draw order is part of the contract: changing it changes every token.
ip := pickIdx(r, plans)
im := pickIdx(r, materials)
il := pickIdx(r, lights)
is := pickIdx(r, scaffolds)
io := pickIdx(r, openingsT)
ig := pickIdx(r, gardens)
iw := pickIdx(r, waters)
hm := r.rangeIn(5, 8)
if p.Plan != anyValue {
ip = findIdx(plans, p.Plan)
}
if p.Material != anyValue {
im = findIdx(materials, p.Material)
}
if p.Light != anyValue {
il = findIdx(lights, p.Light)
}
if !p.Scaffold {
is = 0
}
if ip == 2 && iw == 0 { // Courtyard: the court always holds a pool
iw = 1
}
plan, material, light, scaffold := plans[ip], materials[im], lights[il], scaffolds[is]
openings, garden, water := openingsT[io], gardens[ig], waters[iw]
storeys := hm
if ip == 4 { // Towers
storeys = hm + 2
} else if ip == 5 { // Ruin
storeys = hm - 2
}
t := TraitSet{
Plan: plan.name, Material: material.name, Light: light.name, Scaffold: scaffold.name,
Openings: openings.name, Garden: garden.name, Water: water.name, Storeys: storeys,
material: im,
}
t.Score = plan.score + material.score + light.score + scaffold.score + openings.score + garden.score + water.score
switch {
case t.Score >= scoreMythic:
t.Rarity = "Mythic"
case t.Score >= scoreLegendary:
t.Rarity = "Legendary"
case t.Score >= scoreRare:
t.Rarity = "Rare"
case t.Score >= scoreUncommon:
t.Rarity = "Uncommon"
default:
t.Rarity = "Common"
}
return t
}
// TraitsOf returns the decoded traits of a seed; it panics on invalid params.
func TraitsOf(seed, params string) TraitSet {
return derive(seed, mustParams(params))
}
// TraitString is "Type=Value;…" in TraitTypes order (the golden-vector form
// shared with the TypeScript twin).
func TraitString(seed, params string) string {
var b strings.Builder
for i, tr := range Traits(engine.Input{Seed: seed, Params: params}) {
if i > 0 {
b.WriteString(";")
}
b.WriteString(tr.Type + "=" + tr.Value)
}
return b.String()
}
// ---------------------------------------------------------------------------
// Art
// ---------------------------------------------------------------------------
const (
canvas = 1000
gardenTone = 6 // top-tone key of a roof garden
hexDigits = "0123456789abcdef"
)
func hexVal(c byte) int {
if c >= 'a' {
return int(c-'a') + 10
}
return int(c - '0')
}
// shade adds d to each channel of #rrggbb, clamped to 0..255.
func shade(col string, d int) string {
out := []byte{'#', 0, 0, 0, 0, 0, 0}
for k := 1; k < 7; k += 2 {
v := hexVal(col[k])*16 + hexVal(col[k+1]) + d
if v < 0 {
v = 0
}
if v > 255 {
v = 255
}
out[k] = hexDigits[v>>4]
out[k+1] = hexDigits[v&15]
}
return string(out)
}
func isqrt(n int) int {
if n <= 0 {
return 0
}
x := n
y := (x + 1) / 2
for y < x {
x = y
y = (x + n/x) / 2
}
return x
}
func absInt(x int) int {
if x < 0 {
return -x
}
return x
}
func maxInt(x, y int) int {
if x > y {
return x
}
return y
}
func minInt(x, y int) int {
if x < y {
return x
}
return y
}
func grid(n int) [][]int {
g := make([][]int, n)
for i := range g {
g[i] = make([]int, n)
}
return g
}
func flags(n int) [][]bool {
g := make([][]bool, n)
for i := range g {
g[i] = make([]bool, n)
}
return g
}
func heights(r *rng, plan string, n, peak int) [][]int {
h := grid(n)
for i := 0; i < n; i++ {
for j := 0; j < n; j++ {
k := maxInt(absInt(2*i-(n-1)), absInt(2*j-(n-1))) // 2 x Chebyshev distance from the centre
v := 0
switch plan {
case "Ziggurat":
top := 0
if k <= 1 {
top = 1
}
v = maxInt(1, peak-(k/2)*r.rangeIn(1, 2)+top)
case "Courtyard":
if i == 0 || i == n-1 || j == 0 || j == n-1 {
v = r.rangeIn(3, peak)
} else if k >= n-3 {
v = 1
}
case "Terraces":
v = maxInt(1, peak-((i+j)*peak)/(2*n-2)+r.rangeIn(0, 1))
case "Towers":
v = 1
case "Ruin":
if r.intn(10) < 3 {
v = 0
} else {
v = r.rangeIn(1, peak)
}
default: // Hill Town
dx := 2*i - n - 1
dy := 2*j - n + 2
d := isqrt(dx*dx + dy*dy)
v = maxInt(0, peak-(d*3)/4+r.rangeIn(-1, 1))
if r.intn(9) == 0 {
v = 0
}
}
h[i][j] = minInt(v, peak)
}
}
if plan == "Towers" {
towers := r.rangeIn(4, 8)
for k := 0; k < towers; k++ {
ti := r.intn(n)
tj := r.intn(n)
h[ti][tj] = r.rangeIn(4, peak)
}
}
return h
}
// town is the laid-out maquette: grid, scale and projection origin.
type town struct {
n, a, b, c, ox, oy int
hts [][]int
}
func (t *town) px(i, j int) int { return t.ox + (i-j)*t.a }
func (t *town) py(i, j, z int) int { return t.oy + (i+j)*t.b - z*t.c }
func (t *town) hl(i, j int) int { // height of the neighbour in front-left
if j+1 < t.n {
return t.hts[i][j+1]
}
return 0
}
func (t *town) hr(i, j int) int { // height of the neighbour in front-right
if i+1 < t.n {
return t.hts[i+1][j]
}
return 0
}
func num(b *strings.Builder, v int) { b.WriteString(strconv.Itoa(v)) }
func (t *town) rhomb(b *strings.Builder, x, y int) {
b.WriteString("M")
num(b, x)
b.WriteString(" ")
num(b, y)
b.WriteString("l")
num(b, t.a)
b.WriteString(" ")
num(b, t.b)
num(b, -t.a)
b.WriteString(" ")
num(b, t.b)
num(b, -t.a)
b.WriteString(" ")
num(b, -t.b)
b.WriteString("z")
}
// face writes the visible part of a column's left (side 0) or right (side 1) face.
func (t *town) face(b *strings.Builder, side, i, j int) {
h := t.hts[i][j]
var x, y, lo, dx int
if side == 0 {
lo = t.hl(i, j)
x, y, dx = t.px(i, j+1), t.py(i, j+1, lo), t.a
} else {
lo = t.hr(i, j)
x, y, dx = t.px(i+1, j), t.py(i+1, j, lo), -t.a
}
b.WriteString("M")
num(b, x)
b.WriteString(" ")
num(b, y)
b.WriteString("l")
num(b, dx)
b.WriteString(" ")
num(b, t.b)
b.WriteString("v")
num(b, -(h-lo)*t.c)
b.WriteString("l")
num(b, -dx)
b.WriteString(" ")
num(b, -t.b)
b.WriteString("z")
}
func (t *town) hasFace(side, i, j int) bool {
if side == 0 {
return t.hts[i][j] > t.hl(i, j)
}
return t.hts[i][j] > t.hr(i, j)
}
// opening writes one window (Windows: slot k of 2) or loggia of the bay
// whose tile corner is (u, v).
func opening(b *strings.Builder, openings string, a, u, v, k int) {
ww := maxInt(3, a/8)
wy := (a * 3) / 10
wh := a / 2
x, w := u+a/4, a/2
if openings == "Windows" {
wh = (a * 45) / 100
w = ww
x = u + a/3 - ww/2
if k != 0 {
x = u + (2*a)/3 - ww/2
}
}
b.WriteString("M")
num(b, x)
b.WriteString(" ")
num(b, v+wy)
b.WriteString("h")
num(b, w)
b.WriteString("v")
num(b, wh)
b.WriteString("h")
num(b, -w)
b.WriteString("z")
}
func pathEl(b *strings.Builder, d, attrs string) {
b.WriteString(``)
}
// SVG renders the artwork for a seed and params; it panics on invalid params.
func SVG(seed, params string) string {
tr := derive(seed, mustParams(params))
return draw(seed, tr)
}
func draw(seed string, tr TraitSet) string {
r := newRNG(seed + "|art") // separate stream: art draws never shift traits
n := r.rangeIn(6, 8)
peak := tr.Storeys
hts := heights(r, tr.Plan, n, peak)
water := flags(n)
if tr.Water == "Canal" {
cj := r.rangeIn(1, n-2)
for i := 0; i < n; i++ {
hts[i][cj] = 0
water[i][cj] = true
}
} else if tr.Water == "Pool" {
ci := n/2 - 1
cj := ci
if tr.Plan != "Courtyard" { // towards the front, where the town does not hide it
ci = r.rangeIn(n/2-1, n-2)
cj = r.rangeIn(n/2-1, n-2)
}
for i := ci; i <= ci+1; i++ {
for j := cj; j <= cj+1; j++ {
hts[i][j] = 0
water[i][j] = true
}
}
}
// The landmark: the tallest dry column is raised to the Storeys trait.
li, lj := -1, -1
for i := 0; i < n; i++ {
for j := 0; j < n; j++ {
if !water[i][j] && (li < 0 || hts[i][j] > hts[li][lj]) {
li, lj = i, j
}
}
}
hts[li][lj] = peak
// Per-column choices, scanned row by row.
cols := materialColours[tr.material]
plaster := len(cols) > 1
tone := grid(n)
roof := flags(n)
tree := flags(n)
toneUsed := make([]bool, 6)
roofs, trees := 0, 0
for i := 0; i < n; i++ {
for j := 0; j < n; j++ {
h := hts[i][j]
if h > 0 && plaster {
tone[i][j] = r.intn(6)
}
if h > 0 {
toneUsed[tone[i][j]] = true
}
if tr.Garden == "Roof Gardens" && h > 0 && r.intn(3) == 0 {
roof[i][j] = true
roofs++
}
if tr.Garden == "Cypresses" && !water[i][j] && h <= 3 && r.intn(4) == 0 {
tree[i][j] = true
trees++
}
}
}
// A garden trait is always visible: fall back to the front-most column that can carry it.
if tr.Garden == "Roof Gardens" && roofs == 0 {
done := false
for i := n - 1; i >= 0 && !done; i-- {
for j := n - 1; j >= 0; j-- {
if hts[i][j] > 0 {
roof[i][j] = true
done = true
break
}
}
}
}
if tr.Garden == "Cypresses" && trees == 0 {
// the front-most low dry column, else the front-most dry one
fi, fj, gi, gj := -1, -1, -1, -1
for i := n - 1; i >= 0; i-- {
for j := n - 1; j >= 0; j-- {
if water[i][j] {
continue
}
if gi < 0 {
gi, gj = i, j
}
if fi < 0 && hts[i][j] <= 3 {
fi, fj = i, j
}
}
}
if fi < 0 {
fi, fj = gi, gj
}
tree[fi][fj] = true
}
// Scaffolding: unbuilt storeys on top of a column (or on an empty lot).
scaf := grid(n)
ns := 0
if tr.Scaffold == "Some" {
ns = r.rangeIn(2, 4)
} else if tr.Scaffold == "Heavy" {
ns = r.rangeIn(6, 11)
}
if tr.Plan == "Ruin" && ns > 0 {
ns += 3
}
for k := 0; k < ns; k++ {
si := r.intn(n)
sj := r.intn(n)
for water[si][sj] {
sj = (sj + 1) % n
}
scaf[si][sj] = r.rangeIn(1, 3)
}
sunY := r.rangeIn(130, 200)
sunR := r.rangeIn(50, 80)
night := tr.Light == "Night"
openings := tr.Openings
slots := 1
if openings == "Windows" {
slots = 2
}
// Night: which windows of a 3 x 4 bay tile are lit.
var lit []bool
if night && openings != "Blind" {
for k := 0; k < 12*slots; k++ {
lit = append(lit, r.intn(5) < 2)
}
}
hmax := 0
for i := 0; i < n; i++ {
for j := 0; j < n; j++ {
hmax = maxInt(hmax, hts[i][j]+scaf[i][j])
}
}
// Scale: fit the tallest stack and the plan inside the sheet.
a := minInt(380/n, 1800/(2*hmax+2*n+1))
a -= a % 2
t := &town{n: n, a: a, b: a / 2, c: a, ox: 500, hts: hts} // storey height = bay width: window tiles fit exactly
total := hmax*t.c + n*a + t.c/2
t.oy = (canvas-total)/2 + hmax*t.c + 20
ox, oy, b, c := t.ox, t.oy, t.b, t.c
paper, sun := "#1b2a44", "#e8e4d0"
switch tr.Light {
case "Morning":
paper, sun = "#efe8d8", "#e9b44c"
case "Evening":
paper, sun = "#eadfd0", "#d9643a"
case "Noon":
paper, sun = "#f2efe6", "#f2d27a"
}
gridc, base, ink, winc := "#c9b9a0", "#cdbfa5", "#4a3b2e", "#3a3430"
if night {
gridc, base, ink, winc = "#4a6a9a", "#2c3e60", "#060c18", "#0d1424"
}
// Face tones per material colour: top, left, right.
tops := make([]string, len(cols))
lefts := make([]string, len(cols))
rights := make([]string, len(cols))
for k, col := range cols {
if night {
col = shade(col, -95)
}
switch tr.Light {
case "Morning":
tops[k], lefts[k], rights[k] = shade(col, 40), col, shade(col, -55)
case "Evening":
tops[k], lefts[k], rights[k] = shade(col, 40), shade(col, -55), col
default:
tops[k], lefts[k], rights[k] = shade(col, 55), shade(col, -25), shade(col, -45)
}
}
var o strings.Builder
o.WriteString(``)
o.WriteString(``)
}
if night {
var litd strings.Builder
for by := 0; by < 4; by++ {
for bx := 0; bx < 3; bx++ {
for k := 0; k < slots; k++ {
if lit[(by*3+bx)*slots+k] {
opening(&litd, openings, a, bx*a, by*a, k)
}
}
}
}
if litd.Len() == 0 {
opening(&litd, openings, a, 0, 0, 0)
}
dims := `" width="` + strconv.Itoa(3*a) + `" height="` + strconv.Itoa(4*a) + `" patternUnits="userSpaceOnUse" patternTransform="matrix(1 `
o.WriteString(``)
o.WriteString(``)
}
}
o.WriteString(``)
sx := 820
if tr.Light == "Morning" {
sx = 180
}
o.WriteString(``)
// Plinth, half a storey thick.
na, nb, hc := n*a, n*b, c/2
o.WriteString(``)
o.WriteString(``)
o.WriteString(``)
waterFill := "#3d6f8f"
if night {
waterFill = "#20406a"
}
o.WriteString(``)
// Back to front: columns on one diagonal (i + j = s) never overlap, so
// each diagonal is drawn as a few merged paths, one per fill.
for s := 0; s <= 2*n-2; s++ {
i0 := maxInt(0, s-n+1)
i1 := minInt(s, n-1)
var wd, rip strings.Builder
for i := i0; i <= i1; i++ {
j := s - i
if !water[i][j] {
continue
}
t.rhomb(&wd, t.px(i, j), t.py(i, j, 0))
x, y := t.px(i, j+1), t.py(i, j+1, 0)
rip.WriteString("M" + strconv.Itoa(x+a/2) + " " + strconv.Itoa(y-b/4) + "l" + strconv.Itoa(a/2) + " " + strconv.Itoa(b/4))
rip.WriteString("M" + strconv.Itoa(x+a/2+a/3) + " " + strconv.Itoa(y-b/2-b/4) + "l" + strconv.Itoa(a/2) + " " + strconv.Itoa(b/4))
}
if wd.Len() > 0 {
pathEl(&o, wd.String(), `fill="`+waterFill+`"`)
pathEl(&o, rip.String(), `stroke="#a9d0e0" stroke-width="2"`)
}
// faces: left then right, one path per tone
for side := 0; side < 2; side++ {
for k := 0; k < 6; k++ {
var d strings.Builder
for i := i0; i <= i1; i++ {
j := s - i
if hts[i][j] == 0 || tone[i][j] != k || !t.hasFace(side, i, j) {
continue
}
t.face(&d, side, i, j)
}
if d.Len() == 0 {
continue
}
fill := ""
switch {
case openings == "Blind" && side == 0:
fill = lefts[k]
case openings == "Blind":
fill = rights[k]
case side == 0:
fill = "url(#l" + strconv.Itoa(k) + ")"
default:
fill = "url(#r" + strconv.Itoa(k) + ")"
}
pathEl(&o, d.String(), `fill="`+fill+`"`)
}
}
for k := 0; k <= gardenTone; k++ {
var d strings.Builder
for i := i0; i <= i1; i++ {
j := s - i
h := hts[i][j]
if h == 0 {
continue
}
key := tone[i][j]
if roof[i][j] {
key = gardenTone
}
if key == k {
t.rhomb(&d, t.px(i, j), t.py(i, j, h))
}
}
if d.Len() == 0 {
continue
}
fill := "#7a9a5a"
if k != gardenTone {
fill = tops[k]
}
pathEl(&o, d.String(), `fill="`+fill+`"`)
}
if night && openings != "Blind" {
for side := 0; side < 2; side++ {
var d strings.Builder
for i := i0; i <= i1; i++ {
j := s - i
if t.hasFace(side, i, j) {
t.face(&d, side, i, j)
}
}
if d.Len() == 0 {
continue
}
if side == 0 {
pathEl(&o, d.String(), `fill="url(#nl)" stroke="none"`)
} else {
pathEl(&o, d.String(), `fill="url(#nr)" stroke="none"`)
}
}
}
for i := i0; i <= i1; i++ {
j := s - i
if !tree[i][j] {
continue
}
o.WriteString(``)
}
var sd strings.Builder
for i := i0; i <= i1; i++ {
j := s - i
sc := scaf[i][j]
if sc == 0 {
continue
}
z0 := hts[i][j]
corners := [4][2]int{{i, j}, {i + 1, j}, {i + 1, j + 1}, {i, j + 1}}
for _, cn := range corners {
sd.WriteString("M" + strconv.Itoa(t.px(cn[0], cn[1])) + " " + strconv.Itoa(t.py(cn[0], cn[1], z0)) + "v" + strconv.Itoa(-sc*c))
}
for z := z0 + 1; z <= z0+sc; z++ {
t.rhomb(&sd, t.px(i, j), t.py(i, j, z))
}
sd.WriteString("M" + strconv.Itoa(t.px(i, j+1)) + " " + strconv.Itoa(t.py(i, j+1, z0)) + "l" + strconv.Itoa(a) + " " + strconv.Itoa(b-sc*c))
}
if sd.Len() > 0 {
pathEl(&o, sd.String(), `fill="none" stroke="#b0442c" stroke-width="2" stroke-opacity=".9"`)
}
}
o.WriteString(``)
return o.String()
}