code wiki / (root) / nx_indoorgen_lib.nx
`nx_indoorgen_lib.nx` source

↩ module page · 428 lines · 19111 B
1// nx_indoorgen_lib.nx -- GR6 INDOOR ROOMS BY CONSTRAINT SOLVE (the Infinigen 2.0 expansion,
2// /compare/graphics watch contract ig_room_solve, operator 2026-08-17 "properly emitting in the
3// infinigen way"). COMPOSES the incumbent solver (nx_part_solver_lib, the Infinigen-Indoors
4// transfer) -- one solver in the estate; this file only DECLARES rooms and consumes solutions.
5//
6// Shape: an ARCHETYPE (cottage / hut / stonecot) is data rows here; ig_room_solve(arch,variant,salt)
7// builds a declarative constraint set in memory (envelope + pairwise noclip + door clearance +
8// wall-hug bands + mate face rows), runs ps_solve, then QUANTIZES the solved placements to voxel
9// cells and enforces the pre-declared ACCEPT RULE:
10//     solved AND quantized-disjoint AND door-approach-free AND all-inside.
11// A set that cannot satisfy is REFUSED (return 0, nothing emitted) -- never overlapped furniture.
12// Variants differ by hashed initial placements (different local optima of the SAME constraints --
13// the Infinigen pattern: one program, seeded variation). The world engine consumes only the
14// emitted DATA TABLE (nx_indoorgen_data.nx, written by the nx_indoorgen CLI): the wasm worlds
15// never run the solver, so the solver's mmap arena never meets the wasm memory bound.
16// license_tier: ORIGINAL
17
18import "nx_syscalls.nx"
19import "nx_part_solver_lib.nx"
20
21const IG_CELL: i64 = 16              // solver units per voxel cell (extents are half-units)
22const IG_NARCH: i64 = 3
23const IG_NVAR: i64 = 4
24const IG_SALTS: i64 = 8              // deterministic re-rolls before a variant is REFUSED (4 was
                                   // measured too few: cottage var3 died on a clear-by-4-units
                                   // local optimum at every one of 4 starts; 8 clears it)
27const IG_MAXF: i64 = 16              // emitted furniture rows cap per (arch,variant)
28const IG_CONF_CAP: i64 = 8192
29const IG_NEGCTL: i64 = 99            // the named negative control: a 1x2 room that CANNOT hold a bed
30const IG_NOCLIP_GAP: i64 = 16        // one full cell -> quantized cells can touch, never overlap
31const IG_HUG_LO: i64 = 24            // wall-hug band: off-center, toward the wall ring
32const IG_HUG_HI: i64 = 72
33const IG_MATE_LO: i64 = 16           // mate band: adjacent cells (stool by its table/bed)
34const IG_MATE_HI: i64 = 28
35
36// furniture part kinds
37const IGK_PLAIN: i64 = 1             // one cell, one block at floor+1
38const IGK_BED: i64 = 2               // two cells along the facing axis, white bedding blocks
39const IGK_HEARTH: i64 = 3            // one cell, stone at floor+1 and an ember glow at floor+2
40
41// block ids AS THE ENGINE PALETTE READS THEM (wcol): named here, consumed as data downstream
42const IG_BLK_STONE: i64 = 3
43const IG_BLK_SAND: i64 = 5
44const IG_BLK_WOOD: i64 = 6
45const IG_BLK_SCRUB: i64 = 7          // leaves slot -- reads as thatch on the hut roof
46const IG_BLK_BED: i64 = 8            // snow slot -- reads as white bedding indoors
47const IG_BLK_EMBER: i64 = 11         // gold slot -- the hearth glow
48
49// packed part-row fields (all under bit 31 -- no wide shifts anywhere in this file)
50const IGP_KIND_MASK: i64 = 15        // bits 0-3
51const IGP_BLK_SH: i64 = 4            // bits 4-7
52const IGP_EX_SH: i64 = 8             // bits 8-13
53const IGP_EY_SH: i64 = 14            // bits 14-19
54const IGP_CLR_SH: i64 = 20           // bits 20-26 (door clearance, solver units)
55const IGP_HUG_SH: i64 = 27           // bit 27 (wall-hug band)
56const IGP_MATE_SH: i64 = 28          // bits 28-30 (mate part index + 1)
57
58static IG_CONF: i64
59static IG_ROWS: i64                  // accepted rows: cx | cz<<8 | block<<16 | dy<<24
60static IG_NROWS: i64
61static IG_LASTWHY: i64               // 0 ok / 1 solver-refused / 2 quantize-collision
62
63func ig_reset() -> i64 {
  if IG_CONF == 0 {
      IG_CONF = sys_mmap(IG_CONF_CAP) as i64
      IG_ROWS = sys_mmap(IG_MAXF*8) as i64
  }
  IG_NROWS = 0
  IG_LASTWHY = 0
  return 0
71}
72
73func ig_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
74
75func ig_ws(b: *u8, p: i64, s: *u8) -> i64 {
  var i: i64 = 0
  while s[i] != (0 as u8) { b[p + i] = s[i]; i = i + 1 }
  return p + i
79}
80
81func ig_wn(b: *u8, p: i64, v: i64) -> i64 {
  var q: i64 = p
  var u: i64 = v
  if u < 0 { b[q] = 45 as u8; q = q + 1; u = 0 - u }
  var tmp: i64 = u
  var nd: i64 = 1
  while tmp >= 10 { tmp = tmp/10; nd = nd + 1 }
  var k: i64 = nd - 1
  while k >= 0 {
      var dpow: i64 = 1
      var j: i64 = 0
      while j < k { dpow = dpow*10; j = j + 1 }
      b[q] = (48 + (u/dpow) % 10) as u8
      q = q + 1
      k = k - 1
  }
  return q
98}
99
100// deterministic mul-add-shift mix (the estate's xor-free idiom); always non-negative
101func ig_hash(a: i64, b2: i64) -> i64 {
  var h: i64 = a*374761393 + b2*668265263 + 1442695041
  h = h + (h >> 13)
  h = h*1274126177
  h = h + (h >> 16)
  if h < 0 { h = 0 - h }
  return h
108}
109
110// ---------- ARCHETYPE CANON (data rows; the emitted table mirrors dims/mats and the gate's
111// freshness tooth byte-pins the mirror, so the duplicate cannot drift) ----------
112// dims: interior cells w | d<<8 | wall-height<<16
113func ig_dims(arch: i64) -> i64 {
  if arch == 1 { return 5 | (4 << 8) | (3 << 16) }            // HUT (shore)
  if arch == 2 { return 6 | (5 << 8) | (3 << 16) }            // STONECOT (vale)
  if arch == IG_NEGCTL { return 1 | (2 << 8) | (3 << 16) }    // neg-control: cannot hold a bed
  return 6 | (5 << 8) | (3 << 16)                             // COTTAGE (craft)
118}
119// mats: wall | floor<<8 | roof<<16
120func ig_mats(arch: i64) -> i64 {
  if arch == 1 { return IG_BLK_WOOD | (IG_BLK_SAND << 8) | (IG_BLK_SCRUB << 16) }
  if arch == 2 { return IG_BLK_STONE | (IG_BLK_WOOD << 8) | (IG_BLK_WOOD << 16) }
  return IG_BLK_WOOD | (IG_BLK_STONE << 8) | (IG_BLK_WOOD << 16)
124}
125func ig_doorx(arch: i64) -> i64 { return (ig_dims(arch) & 255)/2 }
126
127func ig_nparts(arch: i64) -> i64 {
  if arch == 1 { return 3 }
  if arch == 2 { return 4 }
  if arch == IG_NEGCTL { return 1 }
  return 5
132}
133
134func ig_mkpart(kind: i64, blk: i64, ex: i64, ey: i64, clr: i64, hug: i64, mate: i64) -> i64 {
  return kind | (blk << IGP_BLK_SH) | (ex << IGP_EX_SH) | (ey << IGP_EY_SH) | (clr << IGP_CLR_SH) | (hug << IGP_HUG_SH) | (mate << IGP_MATE_SH)
136}
137
138// part table per archetype: bed / table / stool / chest / hearth as constraint DATA
139func ig_part(arch: i64, i: i64) -> i64 {
  if arch == 1 {
      if i == 0 { return ig_mkpart(IGK_BED, IG_BLK_BED, 16, 8, 44, 1, 0) }
      if i == 1 { return ig_mkpart(IGK_PLAIN, IG_BLK_WOOD, 8, 8, 36, 1, 0) }      // chest
      return ig_mkpart(IGK_PLAIN, IG_BLK_WOOD, 8, 8, 32, 0, 1)                    // stool by the bed
  }
  if arch == 2 {
      if i == 0 { return ig_mkpart(IGK_BED, IG_BLK_BED, 16, 8, 44, 1, 0) }
      if i == 1 { return ig_mkpart(IGK_PLAIN, IG_BLK_WOOD, 8, 8, 36, 0, 0) }      // table
      if i == 2 { return ig_mkpart(IGK_PLAIN, IG_BLK_WOOD, 8, 8, 36, 1, 0) }      // chest
      return ig_mkpart(IGK_HEARTH, IG_BLK_STONE, 8, 8, 44, 1, 0)
  }
  if arch == IG_NEGCTL {
      return ig_mkpart(IGK_BED, IG_BLK_BED, 16, 8, 0, 0, 0)
  }
  if i == 0 { return ig_mkpart(IGK_BED, IG_BLK_BED, 16, 8, 44, 1, 0) }
  if i == 1 { return ig_mkpart(IGK_PLAIN, IG_BLK_WOOD, 8, 8, 36, 0, 0) }          // table
  if i == 2 { return ig_mkpart(IGK_PLAIN, IG_BLK_WOOD, 8, 8, 32, 0, 2) }          // stool by the table
  if i == 3 { return ig_mkpart(IGK_PLAIN, IG_BLK_WOOD, 8, 8, 36, 1, 0) }          // chest
  return ig_mkpart(IGK_HEARTH, IG_BLK_STONE, 8, 8, 44, 1, 0)
159}
160
161func ig_pname(b: *u8, p: i64, i: i64) -> i64 {
  var q: i64 = ig_ws(b, p, "p" as *u8)
  return ig_wn(b, q, i)
164}
165
166// the accept-rule checker, callable on ANY row set (the gate proves it can FIRE on a planted bad)
167func ig_ck_accept(rows: *i64, nr: i64, w: i64, d: i64, doorx: i64) -> i64 {
  var i: i64 = 0
  while i < nr {
      let cx: i64 = rows[i] & 255
      let cz: i64 = (rows[i] >> 8) & 255
      let dy: i64 = (rows[i] >> 24) & 255
      if cx < 0 { return 0 }
      if cx >= w { return 0 }
      if cz < 0 { return 0 }
      if cz >= d { return 0 }
      if dy == 1 {
          if cx == doorx { if cz <= 1 { return 0 } }         // the door approach stays walkable
          var j: i64 = i + 1
          while j < nr {
              if ((rows[j] >> 24) & 255) == 1 {
                  if (rows[j] & 255) == cx { if ((rows[j] >> 8) & 255) == cz { return 0 } }
              }
              j = j + 1
          }
      }
      i = i + 1
  }
  return 1
190}
191
192// ---------- THE WATCH SYMBOL: build the constraint set, solve, quantize, accept-or-refuse ----------
193func ig_room_solve(arch: i64, variant: i64, salt: i64) -> i64 {
  ig_reset()
  let dims: i64 = ig_dims(arch)
  let w: i64 = dims & 255
  let d: i64 = (dims >> 8) & 255
  let hw: i64 = w*IG_CELL/2
  let hd: i64 = d*IG_CELL/2
  let np: i64 = ig_nparts(arch)
  let b: *u8 = IG_CONF as *u8
  var p: i64 = 0
  // shell + door datum (the door is architecture, typed; furniture is SOLVED)
  p = ig_ws(b, p, "part shell 0 0 0 0\n" as *u8)
  p = ig_ws(b, p, "extent shell " as *u8); p = ig_wn(b, p, hw)
  p = ig_ws(b, p, " " as *u8); p = ig_wn(b, p, hd)
  p = ig_ws(b, p, " 8\npart door 0 0 0 0\nattach door shell 0 " as *u8)
  p = ig_wn(b, p, 0 - hd)
  p = ig_ws(b, p, " 0\n" as *u8)
  // furniture parts: hashed initial placements (variant+salt pick the local optimum)
  var i: i64 = 0
  while i < np {
      let row: i64 = ig_part(arch, i)
      let ex: i64 = (row >> IGP_EX_SH) & 63
      let ey: i64 = (row >> IGP_EY_SH) & 63
      let h1: i64 = ig_hash(arch*131 + i*29 + 3, variant*17 + salt*997 + 5)
      let h2: i64 = ig_hash(arch*151 + i*31 + 7, variant*19 + salt*991 + 11)
      var sx0: i64 = hw - ex
      if sx0 < 1 { sx0 = 1 }
      var sy0: i64 = hd - ey
      if sy0 < 1 { sy0 = 1 }
      let ix: i64 = (h1 % (sx0*2 + 1)) - sx0
      let iy: i64 = (h2 % (sy0*2 + 1)) - sy0
      p = ig_ws(b, p, "part " as *u8); p = ig_pname(b, p, i)
      p = ig_ws(b, p, " " as *u8); p = ig_wn(b, p, ix)
      p = ig_ws(b, p, " " as *u8); p = ig_wn(b, p, iy)
      p = ig_ws(b, p, " 0 0\nextent " as *u8); p = ig_pname(b, p, i)
      p = ig_ws(b, p, " " as *u8); p = ig_wn(b, p, ex)
      p = ig_ws(b, p, " " as *u8); p = ig_wn(b, p, ey)
      p = ig_ws(b, p, " 0\n" as *u8)
      if (row & IGP_KIND_MASK) == IGK_BED {
          if variant % 2 == 1 {
              p = ig_ws(b, p, "facing " as *u8); p = ig_pname(b, p, i)
              p = ig_ws(b, p, " 0 1\n" as *u8)
          }
      }
      i = i + 1
  }
  // constraints: envelope, door clearance, wall-hug, mate bands, pairwise noclip
  i = 0
  while i < np {
      let row: i64 = ig_part(arch, i)
      p = ig_ws(b, p, "envelope " as *u8); p = ig_pname(b, p, i)
      p = ig_ws(b, p, " shell\n" as *u8)
      let dc: i64 = (row >> IGP_CLR_SH) & 127
      if dc > 0 {
          p = ig_ws(b, p, "clear " as *u8); p = ig_pname(b, p, i)
          p = ig_ws(b, p, " door " as *u8); p = ig_wn(b, p, dc)
          p = ig_ws(b, p, "\n" as *u8)
      }
      if ((row >> IGP_HUG_SH) & 1) == 1 {
          p = ig_ws(b, p, "band " as *u8); p = ig_pname(b, p, i)
          p = ig_ws(b, p, " shell " as *u8); p = ig_wn(b, p, IG_HUG_LO)
          p = ig_ws(b, p, " " as *u8); p = ig_wn(b, p, IG_HUG_HI)
          p = ig_ws(b, p, "\n" as *u8)
      }
      let mate: i64 = (row >> IGP_MATE_SH) & 7
      if mate > 0 {
          p = ig_ws(b, p, "band " as *u8); p = ig_pname(b, p, i)
          p = ig_ws(b, p, " " as *u8); p = ig_pname(b, p, mate - 1)
          p = ig_ws(b, p, " " as *u8); p = ig_wn(b, p, IG_MATE_LO)
          p = ig_ws(b, p, " " as *u8); p = ig_wn(b, p, IG_MATE_HI)
          p = ig_ws(b, p, "\nface " as *u8); p = ig_pname(b, p, i)
          p = ig_ws(b, p, " " as *u8); p = ig_pname(b, p, mate - 1)
          p = ig_ws(b, p, "\n" as *u8)
      }
      var j: i64 = i + 1
      while j < np {
          let rj: i64 = ig_part(arch, j)
          var mated: i64 = 0
          if ((rj >> IGP_MATE_SH) & 7) == i + 1 { mated = 1 }
          if ((row >> IGP_MATE_SH) & 7) == j + 1 { mated = 1 }
          if mated == 0 {
              p = ig_ws(b, p, "noclip " as *u8); p = ig_pname(b, p, i)
              p = ig_ws(b, p, " " as *u8); p = ig_pname(b, p, j)
              p = ig_ws(b, p, " " as *u8); p = ig_wn(b, p, IG_NOCLIP_GAP)
              p = ig_ws(b, p, "\n" as *u8)
          }
          j = j + 1
      }
      i = i + 1
  }
  if ps_load(b, p) != 0 { IG_LASTWHY = 1; return 0 }
  if ps_solve() != 1 { IG_LASTWHY = 1; return 0 }
  // quantize to cells + the accept rule (declared in the header, enforced here)
  let nb: *u8 = sys_mmap(64) as *u8
  var nr: i64 = 0
  let rows: *i64 = IG_ROWS as *i64
  i = 0
  while i < np {
      let row: i64 = ig_part(arch, i)
      let kind: i64 = row & IGP_KIND_MASK
      let blk: i64 = (row >> IGP_BLK_SH) & 15
      let q0: i64 = ig_pname(nb, 0, i)
      nb[q0] = 0 as u8
      let pi: i64 = ps_find(nb)
      if pi < 0 { IG_LASTWHY = 1; return 0 }
      let sx: i64 = ps_x(pi)
      let sy: i64 = ps_y(pi)
      if kind == IGK_BED {
          // two cells along the facing axis; head from the low side of the span
          if ps_fy(pi) == 0 {
              var c1x: i64 = (sx - 8 + hw)/IG_CELL
              var c1z: i64 = (sy + hd)/IG_CELL
              if c1x > w - 2 { c1x = w - 2 }
              if c1x < 0 { c1x = 0 }
              if c1z > d - 1 { c1z = d - 1 }
              if c1z < 0 { c1z = 0 }
              rows[nr] = c1x | (c1z << 8) | (blk << 16) | (1 << 24); nr = nr + 1
              rows[nr] = (c1x + 1) | (c1z << 8) | (blk << 16) | (1 << 24); nr = nr + 1
          } else {
              var c2x: i64 = (sx + hw)/IG_CELL
              var c2z: i64 = (sy - 8 + hd)/IG_CELL
              if c2x > w - 1 { c2x = w - 1 }
              if c2x < 0 { c2x = 0 }
              if c2z > d - 2 { c2z = d - 2 }
              if c2z < 0 { c2z = 0 }
              rows[nr] = c2x | (c2z << 8) | (blk << 16) | (1 << 24); nr = nr + 1
              rows[nr] = c2x | ((c2z + 1) << 8) | (blk << 16) | (1 << 24); nr = nr + 1
          }
      } else {
          var cx: i64 = (sx + hw)/IG_CELL
          var cz: i64 = (sy + hd)/IG_CELL
          if cx > w - 1 { cx = w - 1 }
          if cx < 0 { cx = 0 }
          if cz > d - 1 { cz = d - 1 }
          if cz < 0 { cz = 0 }
          rows[nr] = cx | (cz << 8) | (blk << 16) | (1 << 24); nr = nr + 1
          if kind == IGK_HEARTH {
              rows[nr] = cx | (cz << 8) | (IG_BLK_EMBER << 16) | (2 << 24); nr = nr + 1
          }
      }
      i = i + 1
  }
  IG_NROWS = nr
  if ig_ck_accept(rows, nr, w, d, ig_doorx(arch)) != 1 {
      IG_LASTWHY = 2
      IG_NROWS = 0
      return 0
  }
  return 1
342}
343
344func ig_nrows() -> i64 { return IG_NROWS }
345func ig_row(i: i64) -> i64 { let r: *i64 = IG_ROWS as *i64; return r[i] }
346func ig_why() -> i64 { return IG_LASTWHY }
347
348// solve with the deterministic salt ladder; returns the salt used (>=0) or -1 REFUSED
349func ig_solve_salted(arch: i64, variant: i64) -> i64 {
  var salt: i64 = 0
  while salt < IG_SALTS {
      if ig_room_solve(arch, variant, salt) == 1 { return salt }
      salt = salt + 1
  }
  return 0 - 1
356}
357
358// ---------- DATA EMIT: the .nx table the world engine imports (NO timestamp -- regeneration
359// must be byte-identical; that is the gate's freshness tooth) ----------
360func ige_emit(out: *u8) -> i64 {
  var p: i64 = 0
  p = ig_ws(out, p, "// nx_indoorgen_data.nx -- NX-DERIVED: regenerated artefact, not authored source.\n" as *u8)
  p = ig_ws(out, p, "// Emitted by nx_indoorgen (ig_room_solve: constraint-solved room layouts, quantized\n" as *u8)
  p = ig_ws(out, p, "// to voxel cells). DO NOT hand-edit: re-run nx_indoorgen; nx_indoorgen_gate byte-pins\n" as *u8)
  p = ig_ws(out, p, "// this file against a fresh regeneration, so a hand edit goes RED on the next gate run.\n" as *u8)
  p = ig_ws(out, p, "// row: cx | cz<<8 | block<<16 | dy<<24 (interior cells, dy above floor).\n" as *u8)
  p = ig_ws(out, p, "const IGD_NARCH: i64 = " as *u8); p = ig_wn(out, p, IG_NARCH)
  p = ig_ws(out, p, "\nconst IGD_NVAR: i64 = " as *u8); p = ig_wn(out, p, IG_NVAR)
  p = ig_ws(out, p, "\nconst IGD_MAXF: i64 = " as *u8); p = ig_wn(out, p, IG_MAXF)
  p = ig_ws(out, p, "\nfunc igd_dims(a: i64) -> i64 {\n" as *u8)
  var a: i64 = 1
  while a < IG_NARCH {
      p = ig_ws(out, p, "    if a == " as *u8); p = ig_wn(out, p, a)
      p = ig_ws(out, p, " { return " as *u8); p = ig_wn(out, p, ig_dims(a))
      p = ig_ws(out, p, " }\n" as *u8)
      a = a + 1
  }
  p = ig_ws(out, p, "    return " as *u8); p = ig_wn(out, p, ig_dims(0))
  p = ig_ws(out, p, "\n}\nfunc igd_mats(a: i64) -> i64 {\n" as *u8)
  a = 1
  while a < IG_NARCH {
      p = ig_ws(out, p, "    if a == " as *u8); p = ig_wn(out, p, a)
      p = ig_ws(out, p, " { return " as *u8); p = ig_wn(out, p, ig_mats(a))
      p = ig_ws(out, p, " }\n" as *u8)
      a = a + 1
  }
  p = ig_ws(out, p, "    return " as *u8); p = ig_wn(out, p, ig_mats(0))
  p = ig_ws(out, p, "\n}\nfunc igd_doorx(a: i64) -> i64 { return (igd_dims(a) & 255)/2 }\n" as *u8)
  // per-(arch,variant) row counts and rows, flat-keyed
  let nf: *i64 = sys_mmap(IG_NARCH*IG_NVAR*8) as *i64
  let allrows: *i64 = sys_mmap(IG_NARCH*IG_NVAR*IG_MAXF*8) as *i64
  a = 0
  while a < IG_NARCH {
      var v2: i64 = 0
      while v2 < IG_NVAR {
          let salt: i64 = ig_solve_salted(a, v2)
          if salt < 0 { return 0 - (a*100 + v2) - 1 }
          let k: i64 = a*IG_NVAR + v2
          nf[k] = ig_nrows()
          var i: i64 = 0
          while i < ig_nrows() { allrows[k*IG_MAXF + i] = ig_row(i); i = i + 1 }
          v2 = v2 + 1
      }
      a = a + 1
  }
  p = ig_ws(out, p, "func igd_nf(a: i64, v2: i64) -> i64 {\n    let k: i64 = a*IGD_NVAR + v2\n" as *u8)
  var k2: i64 = 0
  while k2 < IG_NARCH*IG_NVAR {
      p = ig_ws(out, p, "    if k == " as *u8); p = ig_wn(out, p, k2)
      p = ig_ws(out, p, " { return " as *u8); p = ig_wn(out, p, nf[k2])
      p = ig_ws(out, p, " }\n" as *u8)
      k2 = k2 + 1
  }
  p = ig_ws(out, p, "    return 0\n}\nfunc igd_f(a: i64, v2: i64, i: i64) -> i64 {\n    let k: i64 = (a*IGD_NVAR + v2)*IGD_MAXF + i\n" as *u8)
  k2 = 0
  while k2 < IG_NARCH*IG_NVAR {
      var i3: i64 = 0
      while i3 < nf[k2] {
          p = ig_ws(out, p, "    if k == " as *u8); p = ig_wn(out, p, k2*IG_MAXF + i3)
          p = ig_ws(out, p, " { return " as *u8); p = ig_wn(out, p, allrows[k2*IG_MAXF + i3])
          p = ig_ws(out, p, " }\n" as *u8)
          i3 = i3 + 1
      }
      k2 = k2 + 1
  }
  p = ig_ws(out, p, "    return 0\n}\n" as *u8)
  return p
428}
nx_indoorgen_lib.nx source

`nx_indoorgen_lib.nx` source
