File size: 12,307 Bytes
2b0432b
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4b7c857
2b0432b
 
 
 
 
 
 
4b7c857
2b0432b
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
// World layout: river path, terrain height field and placement of every
// landmark. Units are metres, +y is up, the sun sets toward -x (west).
import { clamp, fbm2, lerp, mulberry32, ridged2, smoothstep, valueNoise2 } from './rng'

// ---------------------------------------------------------------- river path
const RIVER_CTRL: [number, number][] = [
  [-1500, -330], [-1050, -260], [-760, -150], [-520, -70], [-330, -22], [-190, 6], [-80, 14],
  [30, 4], [120, -10], [220, 6], [330, 46], [470, 92], [660, 104], [900, 60], [1300, -40], [1700, -120],
]

function catmull(p0: number, p1: number, p2: number, p3: number, t: number) {
  const t2 = t * t, t3 = t2 * t
  return 0.5 * (2 * p1 + (-p0 + p2) * t + (2 * p0 - 5 * p1 + 4 * p2 - p3) * t2 + (-p0 + 3 * p1 - 3 * p2 + p3) * t3)
}

export interface RiverSample { x: number; z: number; tx: number; tz: number; s: number }

function buildRiver(): RiverSample[] {
  const raw: [number, number][] = []
  const n = RIVER_CTRL.length
  for (let i = 0; i < n - 1; i++) {
    const p0 = RIVER_CTRL[Math.max(0, i - 1)], p1 = RIVER_CTRL[i], p2 = RIVER_CTRL[i + 1], p3 = RIVER_CTRL[Math.min(n - 1, i + 2)]
    const steps = 80
    for (let k = 0; k < steps; k++) {
      const t = k / steps
      raw.push([catmull(p0[0], p1[0], p2[0], p3[0], t), catmull(p0[1], p1[1], p2[1], p3[1], t)])
    }
  }
  raw.push(RIVER_CTRL[n - 1])
  // resample by arc length every 2 m
  const cum: number[] = [0]
  for (let i = 1; i < raw.length; i++) cum.push(cum[i - 1] + Math.hypot(raw[i][0] - raw[i - 1][0], raw[i][1] - raw[i - 1][1]))
  const total = cum[cum.length - 1]
  const out: RiverSample[] = []
  let j = 0
  for (let s = 0; s <= total; s += 2) {
    while (j < cum.length - 2 && cum[j + 1] < s) j++
    const f = (s - cum[j]) / Math.max(1e-6, cum[j + 1] - cum[j])
    const x = lerp(raw[j][0], raw[j + 1][0], f), z = lerp(raw[j][1], raw[j + 1][1], f)
    out.push({ x, z, tx: 0, tz: 0, s })
  }
  for (let i = 0; i < out.length; i++) {
    const a = out[Math.max(0, i - 2)], b = out[Math.min(out.length - 1, i + 2)]
    const l = Math.hypot(b.x - a.x, b.z - a.z) || 1
    out[i].tx = (b.x - a.x) / l
    out[i].tz = (b.z - a.z) / l
  }
  return out
}

export const RIVER = buildRiver()
export const RIVER_LEN = RIVER[RIVER.length - 1].s

/** s (arc length) of the river point nearest to x (river runs roughly along +x). */
export function riverSAtX(x: number) {
  let best = 0, bd = 1e9
  for (let i = 0; i < RIVER.length; i++) {
    const d = Math.abs(RIVER[i].x - x)
    if (d < bd) { bd = d; best = i }
  }
  return RIVER[best].s
}

export function riverAt(s: number): RiverSample {
  const f = clamp(s / 2, 0, RIVER.length - 1.001)
  const i = Math.floor(f), t = f - i
  const a = RIVER[i], b = RIVER[i + 1]
  const tx = lerp(a.tx, b.tx, t), tz = lerp(a.tz, b.tz, t)
  const l = Math.hypot(tx, tz) || 1
  return { x: lerp(a.x, b.x, t), z: lerp(a.z, b.z, t), tx: tx / l, tz: tz / l, s }
}

/** Point at arc length s, offset sideways by `off` (+ = south bank / +z side). */
export function riverPoint(s: number, off: number) {
  const r = riverAt(s)
  // left normal of the flow direction (flow is +x, normal points +z = south)
  const nx = -r.tz, nz = r.tx
  return { x: r.x + nx * off, z: r.z + nz * off, tx: r.tx, tz: r.tz, nx, nz, angle: Math.atan2(r.tx, r.tz) }
}

export const VILLAGE_S0 = riverSAtX(-300)
export const VILLAGE_S1 = riverSAtX(290)

/** Half width of the water surface. Narrow, walled canal inside the village. */
export function riverHalfWidth(s: number) {
  const inV = smoothstep(VILLAGE_S0 - 120, VILLAGE_S0, s) * (1 - smoothstep(VILLAGE_S1, VILLAGE_S1 + 120, s))
  return lerp(13 + 3 * valueNoise2(s * 0.01, 3), 8, inV)
}

export function villageFactor(s: number) {
  return smoothstep(VILLAGE_S0 - 30, VILLAGE_S0 + 10, s) * (1 - smoothstep(VILLAGE_S1 - 10, VILLAGE_S1 + 30, s))
}

// spatial hash of river samples for fast distance queries
const CELL = 24
const GRID = new Map<number, number[]>()
{
  for (let i = 0; i < RIVER.length; i++) {
    const cx = Math.floor(RIVER[i].x / CELL), cz = Math.floor(RIVER[i].z / CELL)
    for (let dx = -3; dx <= 3; dx++) for (let dz = -3; dz <= 3; dz++) {
      const k = (cx + dx) * 100003 + (cz + dz)
      let arr = GRID.get(k)
      if (!arr) { arr = []; GRID.set(k, arr) }
      arr.push(i)
    }
  }
}

export interface RiverQuery { d: number; s: number; side: number }
const FAR: RiverQuery = { d: 72, s: 0, side: 1 }

/** Distance to the river centreline (capped at ~72 m beyond which it is approximate). */
export function riverQuery(x: number, z: number): RiverQuery {
  const k = Math.floor(x / CELL) * 100003 + Math.floor(z / CELL)
  const arr = GRID.get(k)
  if (!arr) return riverQueryFar(x, z)
  let bd = 1e18, bi = -1
  for (const i of arr) {
    const p = RIVER[i]
    const d = (p.x - x) ** 2 + (p.z - z) ** 2
    if (d < bd) { bd = d; bi = i }
  }
  const p = RIVER[bi]
  const side = (x - p.x) * -p.tz + (z - p.z) * p.tx >= 0 ? 1 : -1
  return { d: Math.sqrt(bd), s: p.s, side }
}

function riverQueryFar(x: number, z: number): RiverQuery {
  // coarse search on every 10th sample
  let bd = 1e18, bi = 0
  for (let i = 0; i < RIVER.length; i += 10) {
    const p = RIVER[i]
    const d = (p.x - x) ** 2 + (p.z - z) ** 2
    if (d < bd) { bd = d; bi = i }
  }
  const p = RIVER[bi]
  const side = (x - p.x) * -p.tz + (z - p.z) * p.tx >= 0 ? 1 : -1
  return { d: Math.max(FAR.d, Math.sqrt(bd)), s: p.s, side }
}

// ---------------------------------------------------------------- terrain
export const GROUND_Y = 1.7

export const TERRACE = { cx: 330, cz: -470, rx: 230, rz: 170, step: 2.6 }

export function terraceMask(x: number, z: number) {
  const u = (x - TERRACE.cx) / TERRACE.rx, v = (z - TERRACE.cz) / TERRACE.rz
  const r = Math.sqrt(u * u + v * v) + (valueNoise2(x * 0.02, z * 0.02, 41) - 0.5) * 0.25
  return 1 - smoothstep(0.78, 1.0, r)
}

function baseHeight(x: number, z: number, q: RiverQuery) {
  const d = q.d
  // gentle undulating fields outside the village
  let h = GROUND_Y + (fbm2(x * 0.012, z * 0.012, 3, 5) - 0.5) * 1.6 * smoothstep(50, 140, d)
  // valley walls: the further from the river the higher the hills
  const far = Math.hypot(x * 0.8, z)
  const hd = Math.min(d, far * 0.9 + 40)
  const hillT = smoothstep(130, 560, hd)
  h += hillT * hillT * (60 + 190 * fbm2(x * 0.0022 + 3, z * 0.0022, 5, 7))
  h += hillT * (ridged2(x * 0.0045, z * 0.0045, 5, 3) - 0.35) * 70 * hillT
  // small knolls inside the valley (bamboo groves)
  h += smoothstep(70, 160, d) * Math.max(0, fbm2(x * 0.006, z * 0.006, 3, 19) - 0.55) * 60
  return h
}

/** Height of the visible ground (river channel carved in). */
export function terrainHeight(x: number, z: number, carveTerraces = true) {
  const q = riverQuery(x, z)
  let h = baseHeight(x, z, q)
  // terraces carved into the hillside
  const m = terraceMask(x, z)
  if (m > 0) {
    const hq = terraceQuantize(h)
    h = lerp(h, hq, m)
    if (carveTerraces) h -= m * 1.2 // the detailed terrace mesh sits on top
  }
  // river channel
  const w = riverHalfWidth(q.s)
  const vf = villageFactor(q.s)
  if (q.d < w + 30) {
    const bankW = lerp(9, 1.2, vf)
    const bank = smoothstep(w - bankW * 0.6, w + bankW * 0.4, q.d)
    const bed = -2.6 + (1 - smoothstep(0, w, q.d)) * -0.8
    h = lerp(bed, h, bank)
  }
  return h
}

export function terraceQuantize(h: number) {
  const u = h / TERRACE.step
  const f = u - Math.floor(u)
  // flat paddy (82%), steep riser; slight bund lip at the outer edge
  const riser = smoothstep(0.8, 1.0, f)
  const lip = Math.exp(-((f - 0.04) ** 2) / 0.0006) * 0.12
  return TERRACE.step * (Math.floor(u) + riser) + lip
}

export function terraceHeight(x: number, z: number) {
  const q = riverQuery(x, z)
  const h = baseHeight(x, z, q)
  const m = terraceMask(x, z)
  return lerp(h, terraceQuantize(h), m)
}

/** 0..1 value describing the position inside a terrace step (for water vs riser). */
export function terraceStepFrac(x: number, z: number) {
  const q = riverQuery(x, z)
  const h = baseHeight(x, z, q)
  const u = h / TERRACE.step
  return u - Math.floor(u)
}

/** Far mountain ring height (beyond the detailed terrain). */
export function farMountainHeight(x: number, z: number) {
  const r = Math.hypot(x, z)
  const ang = Math.atan2(z, x)
  // the sunset side (west-north-west) opens into a broad low valley so the sun
  // stays visible until it is almost on the horizon; other sides are higher ranges
  let dSun = ang - (Math.PI + 0.2)
  dSun = Math.atan2(Math.sin(dSun), Math.cos(dSun))
  const west = Math.exp(-(dSun * dSun) / 0.5)
  const gap = 1 - 0.5 * Math.exp(-((ang + 0.05) ** 2) / 0.02)
  const rise = smoothstep(700, 2600, r)
  let h = rise * (150 + 360 * ridged2(x * 0.0009, z * 0.0009, 6, 77)) * gap * (1 - 0.74 * west)
  h += smoothstep(600, 1400, r) * 90 * fbm2(x * 0.002, z * 0.002, 4, 9) * (1 - 0.5 * west)
  return h
}

// ---------------------------------------------------------------- placements
export interface HouseSpec {
  x: number; z: number; rot: number // rotation about y; local +z faces the street / river
  w: number; d: number; floors: number; gableSteps: number
  shop: boolean; side: number; s: number; seed: number
  chimney: boolean; lantern: boolean; order: number // lantern / window lighting order
}

export interface Landmarks {
  bridgeS: number; wheelS: number; treeS: number; marketS0: number; marketS1: number
}

export const BRIDGE_S = riverSAtX(40)
export const WHEEL_S = riverSAtX(-196)
export const TREE_POS = (() => { const p = riverPoint(riverSAtX(-300), -34); return { x: p.x, z: p.z } })()
export const MARKET_S0 = riverSAtX(-130)
export const MARKET_S1 = riverSAtX(30)
export const PAVILION_POS = { x: 205, z: -372 }

function blocked(s: number, side: number, half: number) {
  if (Math.abs(s - BRIDGE_S) < half + 8) return true
  if (side > 0 && Math.abs(s - WHEEL_S) < half + 10) return true
  if (side < 0 && s < riverSAtX(-264) + half) return true // entrance plaza with the camphor tree
  return false
}

export function buildHouses(): HouseSpec[] {
  const rng = mulberry32(20261022)
  const out: HouseSpec[] = []
  const rows = [
    { side: -1, off: 14.6, shop: true, jitter: 0.3 },   // north: market street shops behind a 6 m quay
    { side: 1, off: 8.4, shop: false, jitter: 0.2 },    // south: houses standing right on the water
    { side: -1, off: 31, shop: false, jitter: 2.5 },
    { side: 1, off: 25, shop: false, jitter: 2.5 },
    { side: -1, off: 50, shop: false, jitter: 5 },
    { side: 1, off: 44, shop: false, jitter: 5 },
  ]
  let order = 0
  for (const row of rows) {
    let s = VILLAGE_S0 + rng() * 6 + (row.off > 20 ? 10 : 0)
    const sEnd = VILLAGE_S1 - (row.off > 40 ? 40 : 0)
    while (s < sEnd) {
      const w = 8 + rng() * 5
      const half = w / 2
      const sc = s + half
      if (row.off > 40 && rng() < 0.3) { s += w + 6; continue }
      if (!blocked(sc, row.side, half)) {
        const d = 8.5 + rng() * 3.5
        const off = row.side * (row.off + d / 2 + (rng() - 0.5) * row.jitter)
        const p = riverPoint(sc, off)
        // front faces the river: local +z points toward the centreline
        const facing = Math.atan2(-row.side * p.nx, -row.side * p.nz)
        const floors = rng() < (row.shop ? 0.75 : 0.55) ? 2 : 1
        out.push({
          x: p.x, z: p.z, rot: facing + (rng() - 0.5) * 0.05 * (row.off > 20 ? 3 : 1),
          w, d, floors, gableSteps: floors === 2 ? (rng() < 0.6 ? 3 : 2) : (rng() < 0.5 ? 2 : 1),
          shop: row.shop, side: row.side, s: sc, seed: Math.floor(rng() * 1e9),
          chimney: rng() < 0.35, lantern: row.off < 20, order: order++,
        })
      }
      s += w + (row.shop ? 0.2 + rng() * 0.6 : 0.6 + rng() * 3.5)
      if (row.side > 0 && row.off < 10 && rng() < 0.18) s += 5 // water steps / alleys between houses
    }
  }
  return out
}

/** Path the ox cart and walkers follow along the north quay (market street). */
export function quayPoint(s: number, lane = 0) {
  return riverPoint(s, -(11 + lane))
}

export function terrainNormalApprox(x: number, z: number) {
  const e = 1.5
  const hx = terrainHeight(x + e, z) - terrainHeight(x - e, z)
  const hz = terrainHeight(x, z + e) - terrainHeight(x, z - e)
  const l = Math.hypot(hx, 2 * e, hz)
  return { x: -hx / l, y: (2 * e) / l, z: -hz / l }
}