const p = require('builtin/primitives'); // ── Deterministic pseudo-random ── function hash(n) { let x = Math.sin(n * 127.1 + 311.7) * 43758.5453; return x - Math.floor(x); } function hashRange(n, lo, hi) { return lo + hash(n) * (hi - lo); } // ── MATERIALS ── const BASALT = { color: 'oklch(0.22 0.01 250)', texture: '/cdn/texture-stone-rough.png', roughness: 0.95, }; const OBSIDIAN = { color: 'oklch(0.15 0.02 270)', texture: '/cdn/texture-stone-rough.png', roughness: 0.35, metalness: 0.15, }; const CHARCOAL = { color: 'oklch(0.26 0.02 55)', texture: '/cdn/texture-stone-rough.png', roughness: 0.92, }; const CRACKED = { color: 'oklch(0.18 0.04 30)', texture: '/cdn/texture-stone-rough.png', emissive: 'oklch(0.55 0.22 38)', emissiveIntensity: 1.2, roughness: 0.88, }; const CRACKED_HOT = { color: 'oklch(0.16 0.05 25)', texture: '/cdn/texture-stone-rough.png', emissive: 'oklch(0.65 0.28 42)', emissiveIntensity: 2.0, roughness: 0.85, }; const DARK_STONE = { color: 'oklch(0.30 0.015 80)', texture: '/cdn/texture-stone-rough.png', roughness: 0.90, }; const GRAY_BASALT = { color: 'oklch(0.33 0.01 240)', texture: '/cdn/texture-stone-rough.png', roughness: 0.93, }; const MATS = [BASALT, BASALT, OBSIDIAN, CHARCOAL, DARK_STONE, BASALT, GRAY_BASALT, CHARCOAL]; function pickMat(seed) { return MATS[Math.abs(Math.floor(seed * 73.1)) % MATS.length]; } function maybeCracked(seed) { return hash(seed * 3.7) < 0.18 ? CRACKED : (hash(seed * 5.1) < 0.08 ? CRACKED_HOT : pickMat(seed)); } // ── Slight rotation for natural feel ── function natRot(seed) { return { yaw: hashRange(seed, -12, 12), pitch: hashRange(seed + 50, -5, 5), roll: hashRange(seed + 100, -5, 5), }; } // ── Helper: build a chunky volcanic rock from overlapping primitives ── // cx, cz = center, baseY = bottom, topY = approx top, radius = approx half-width function buildRock(api, tag, cx, baseY, cz, radius, topY, seed, P) { const h = topY - baseY; const mat = maybeCracked(seed); const mat2 = pickMat(seed + 1); const mat3 = maybeCracked(seed + 2); const r = radius; const opts = { parent: P }; const rOpts = { parent: P, rotation: natRot(seed) }; // Main body — cylinder going deep p.cyl(api, tag, cx, baseY - 3, cz, r * 0.85, topY - h * 0.15, mat, 6, opts); // Top cap — slightly wider, flatter for landing p.cyl(api, tag + '-cap', cx + hashRange(seed + 10, -0.3, 0.3), topY - h * 0.25, cz + hashRange(seed + 11, -0.3, 0.3), r * 0.95, topY, mat2, 5, rOpts); // Rough overhang chunks p.box(api, tag + '-r1', cx - r * 0.6, baseY + h * 0.1, cz - r * 0.7, cx + r * 0.8, baseY + h * 0.55, cz + r * 0.5, mat3, rOpts); // Smaller detail if (hash(seed + 20) > 0.4) { p.box(api, tag + '-r2', cx + hashRange(seed + 30, -r * 0.4, r * 0.4), topY - h * 0.3, cz + hashRange(seed + 31, -r * 0.3, r * 0.3), cx + hashRange(seed + 32, r * 0.2, r * 0.7), topY + 0.2, cz + hashRange(seed + 33, r * 0.1, r * 0.5), mat, { parent: P, rotation: natRot(seed + 5) }); } } // ── Helper: tall pillar ── function buildPillar(api, tag, cx, baseY, cz, radius, topY, seed, P) { const mat = maybeCracked(seed); const mat2 = pickMat(seed + 2); const mat3 = maybeCracked(seed + 4); const r = radius; // Main column — hexagonal basalt look (6 segments) p.cyl(api, tag, cx, baseY - 5, cz, r, topY - 0.5, mat, 6, { parent: P }); // Top platform — slightly wider p.cyl(api, tag + '-top', cx, topY - 0.8, cz, r * 1.15, topY + 0.1, mat2, 6, { parent: P, rotation: natRot(seed) }); // Flared base p.frustum(api, tag + '-base', cx, baseY - 2, cz, r * 1.4, r, baseY + 2, mat3, { parent: P }); // Random outcrop const ox = hashRange(seed + 40, -1, 1); const oz = hashRange(seed + 41, -1, 1); p.box(api, tag + '-out', cx + ox - r * 0.5, baseY + (topY - baseY) * hashRange(seed + 42, 0.2, 0.6), cz + oz - r * 0.4, cx + ox + r * 0.5, baseY + (topY - baseY) * hashRange(seed + 43, 0.5, 0.8), cz + oz + r * 0.4, maybeCracked(seed + 5), { parent: P, rotation: natRot(seed + 3) }); } // ── Helper: rocky island (big chunky mass) ── function buildIsland(api, tag, cx, baseY, cz, width, depth, topY, seed, P) { const mat = maybeCracked(seed); const mat2 = pickMat(seed + 1); const mat3 = maybeCracked(seed + 3); const mat4 = pickMat(seed + 5); const hw = width / 2, hd = depth / 2; const h = topY - baseY; // Main mass p.box(api, tag, cx - hw, baseY - 4, cz - hd, cx + hw, topY, cz + hd, mat, { parent: P, rotation: natRot(seed) }); // Top layer — slightly offset for rough surface p.box(api, tag + '-top', cx - hw * 0.9 + hashRange(seed + 10, -0.5, 0.5), topY - 0.5, cz - hd * 0.85 + hashRange(seed + 11, -0.5, 0.5), cx + hw * 0.85, topY + 0.3, cz + hd * 0.9, mat2, { parent: P, rotation: natRot(seed + 1) }); // Underside stalactite-like chunks p.cone(api, tag + '-hang1', cx + hashRange(seed + 20, -hw * 0.4, hw * 0.4), baseY - 6, cz + hashRange(seed + 21, -hd * 0.4, hd * 0.4), width * 0.3, baseY, mat3, 5, { parent: P }); p.cone(api, tag + '-hang2', cx + hashRange(seed + 22, -hw * 0.3, hw * 0.3), baseY - 4, cz + hashRange(seed + 23, -hd * 0.3, hd * 0.3), width * 0.2, baseY + 1, mat4, 5, { parent: P }); // Side outcrop p.box(api, tag + '-side', cx + hw * 0.5, baseY + h * 0.1, cz - hd * 0.3, cx + hw * 1.15, topY - h * 0.3, cz + hd * 0.4, mat3, { parent: P, rotation: natRot(seed + 2) }); // Extra rubble on top p.cyl(api, tag + '-rub', cx + hashRange(seed + 30, -hw * 0.3, hw * 0.3), topY - 0.1, cz + hashRange(seed + 31, -hd * 0.3, hd * 0.3), hashRange(seed + 32, 0.8, 1.8), topY + hashRange(seed + 33, 0.3, 1.2), mat4, 5, { parent: P, rotation: natRot(seed + 4) }); } export function onSpawn(api) { const P = api.id; // ═══════════════════════════════════════ // 1. STEPPING STONES — near spawn heading -Z // ═══════════════════════════════════════ const stones = [ { x: 1, z: -12, r: 2.0, topY: 7.5 }, { x: -1, z: -17, r: 1.8, topY: 8.2 }, { x: 2, z: -22, r: 2.2, topY: 7.0 }, { x: -2, z: -27, r: 1.6, topY: 8.8 }, { x: 0, z: -32, r: 2.5, topY: 7.2 }, { x: 3, z: -37, r: 1.9, topY: 9.0 }, { x: -1, z: -42, r: 2.3, topY: 7.8 }, { x: 1, z: -47, r: 2.0, topY: 8.5 }, { x: -3, z: -52, r: 2.1, topY: 7.5 }, { x: 2, z: -56, r: 1.7, topY: 9.2 }, ]; for (let i = 0; i < stones.length; i++) { const s = stones[i]; buildRock(api, 'step-' + i, s.x, 2, s.z, s.r, s.topY, i * 7.3, P); } // ═══════════════════════════════════════ // 2. ROCK BRIDGE — heading -Z, -X (~40m span) // ═══════════════════════════════════════ // Bridge from roughly (-5, -58) to (-35, -85) const bridgeSegs = 14; const bStartX = -3, bStartZ = -58; const bEndX = -38, bEndZ = -88; for (let i = 0; i <= bridgeSegs; i++) { const t = i / bridgeSegs; const bx = bStartX + (bEndX - bStartX) * t; const bz = bStartZ + (bEndZ - bStartZ) * t; // Arch shape: higher in the middle const archY = 7.5 + Math.sin(t * Math.PI) * 8; const w = hashRange(i * 13.1, 1.2, 2.0); const segLen = 3.5; const mat = maybeCracked(i * 5.7); const mat2 = pickMat(i * 3.2); // Main bridge segment p.box(api, 'brg-' + i, bx - w, archY - 1.5, bz - segLen / 2, bx + w, archY + 0.4, bz + segLen / 2, mat, { parent: P, rotation: natRot(i * 4.1) }); // Support pillar underneath (only for some segments) if (i > 1 && i < bridgeSegs - 1 && i % 3 === 0) { p.cyl(api, 'brg-pil-' + i, bx, 0, bz, w * 0.7, archY - 1, mat2, 6, { parent: P }); } // Rough surface bumps if (hash(i * 9.3) > 0.3) { p.box(api, 'brg-bump-' + i, bx + hashRange(i * 11, -w * 0.5, w * 0.3), archY + 0.2, bz + hashRange(i * 12, -1, 1), bx + hashRange(i * 13, w * 0.1, w * 0.7), archY + hashRange(i * 14, 0.4, 1.0), bz + hashRange(i * 15, 0.2, 1.5), pickMat(i * 2.3), { parent: P, rotation: natRot(i * 6) }); } // Gap in bridge (two spots — just narrow the segment) if (i === 5 || i === 10) { // Skip one segment to create a gap — the next segment is reachable by hop } } // Bridge abutments (thick rock masses at both ends) buildRock(api, 'brg-start', bStartX, 2, bStartZ, 3.5, 8.5, 200, P); buildRock(api, 'brg-end', bEndX, 2, bEndZ, 4.0, 8.0, 210, P); // ═══════════════════════════════════════ // 3. PILLAR FIELD — east side (x:40-80, z:-40 to -100) // ═══════════════════════════════════════ const pillars = [ { x: 45, z: -42, r: 1.8, topY: 16 }, { x: 52, z: -48, r: 1.5, topY: 19 }, { x: 58, z: -44, r: 2.0, topY: 14 }, { x: 48, z: -56, r: 1.3, topY: 21 }, { x: 55, z: -62, r: 1.7, topY: 17 }, { x: 63, z: -55, r: 2.2, topY: 13 }, { x: 70, z: -60, r: 1.4, topY: 22 }, { x: 65, z: -70, r: 1.9, topY: 15 }, { x: 50, z: -75, r: 1.6, topY: 20 }, { x: 58, z: -82, r: 2.1, topY: 12 }, { x: 72, z: -78, r: 1.5, topY: 18 }, { x: 68, z: -88, r: 1.8, topY: 16 }, { x: 55, z: -92, r: 2.0, topY: 14 }, { x: 75, z: -95, r: 1.3, topY: 23 }, ]; for (let i = 0; i < pillars.length; i++) { const pl = pillars[i]; buildPillar(api, 'pil-' + i, pl.x, 2, pl.z, pl.r, pl.topY, 300 + i * 11.3, P); } // Connecting ledge chunks between some pillars (for easier traversal) const pillarLinks = [[0, 2], [1, 3], [4, 5], [6, 7], [8, 9], [10, 11], [12, 13]]; for (let li = 0; li < pillarLinks.length; li++) { const [a, b] = pillarLinks[li]; const pa = pillars[a], pb = pillars[b]; const midX = (pa.x + pb.x) / 2; const midZ = (pa.z + pb.z) / 2; const midY = Math.min(pa.topY, pb.topY) - 2; p.box(api, 'pil-link-' + li, midX - 1, midY - 0.5, midZ - 1, midX + 1, midY + 0.3, midZ + 1, maybeCracked(400 + li * 7), { parent: P, rotation: natRot(400 + li) }); } // ═══════════════════════════════════════ // 4. ISLAND CHAIN — south-west (x:-40 to -80, z:-60 to -120) // ═══════════════════════════════════════ const islands = [ { x: -42, z: -65, w: 10, d: 8, topY: 9 }, { x: -55, z: -78, w: 8, d: 7, topY: 12 }, { x: -48, z: -90, w: 12, d: 9, topY: 8 }, { x: -65, z: -95, w: 9, d: 10, topY: 14 }, { x: -58, z: -110, w: 7, d: 8, topY: 10 }, { x: -75, z: -118, w: 11, d: 9, topY: 11 }, ]; for (let i = 0; i < islands.length; i++) { const isl = islands[i]; buildIsland(api, 'isle-' + i, isl.x, 3, isl.z, isl.w, isl.d, isl.topY, 500 + i * 13.7, P); } // ═══════════════════════════════════════ // 5. THE SPINE — far north (z:-140 to -180), running E-W ~60m // ═══════════════════════════════════════ const spineStartX = -30, spineEndX = 30; const spineZ = -160; const spineSegs = 22; for (let i = 0; i <= spineSegs; i++) { const t = i / spineSegs; const sx = spineStartX + (spineEndX - spineStartX) * t; const sz = spineZ + hashRange(i * 17.3, -4, 4); // wandering line // Height varies — peaks and valleys const peakT = Math.sin(t * Math.PI * 3.5) * 0.5 + 0.5; const spineH = 12 + peakT * 13; // 12-25m above lava const topY = 3 + spineH; const w = hashRange(i * 19.1, 0.6, 1.4); // narrow! const mat = maybeCracked(600 + i * 5.3); const mat2 = pickMat(600 + i * 3.1); // Main spine vertebra p.box(api, 'spine-' + i, sx - w, 0, sz - w * 1.2, sx + w, topY, sz + w * 1.2, mat, { parent: P, rotation: natRot(600 + i * 2) }); // Pointed top (like a dorsal fin) if (peakT > 0.5) { p.cone(api, 'spine-peak-' + i, sx, topY - 1, sz, w * 0.8, topY + hashRange(i * 21, 1, 4), mat2, 4, { parent: P, rotation: natRot(600 + i * 3) }); } // Footholds — small ledges jutting out if (i % 2 === 0) { const side = (i % 4 === 0) ? 1 : -1; p.box(api, 'spine-foot-' + i, sx + side * w, topY * hashRange(i * 23, 0.3, 0.7), sz - 0.6, sx + side * (w + hashRange(i * 24, 0.8, 1.8)), topY * hashRange(i * 25, 0.35, 0.75) + 0.5, sz + 0.6, pickMat(600 + i * 4), { parent: P }); } // Buttress supports at base (every 3rd) if (i % 3 === 0) { const bw = w + hashRange(i * 27, 1.5, 3); p.frustum(api, 'spine-but-' + i, sx, 0, sz, bw, w * 0.8, 5, mat, { parent: P }); } } // ═══════════════════════════════════════ // 6. SCATTERED MEGA-BOULDERS — throughout caldera // ═══════════════════════════════════════ const megaBoulders = [ { x: 20, z: -25, r: 4.0, topY: 10 }, { x: -25, z: -35, r: 5.0, topY: 8 }, { x: 35, z: -15, r: 3.5, topY: 11 }, { x: -15, z: -80, r: 4.5, topY: 9 }, { x: 80, z: -50, r: 3.8, topY: 7 }, // partially submerged { x: -85, z: -70, r: 5.5, topY: 12 }, { x: 10, z: -120, r: 4.2, topY: 10 }, { x: -30, z: -140, r: 3.5, topY: 8 }, { x: 50, z: -130, r: 4.8, topY: 11 }, { x: -60, z: -40, r: 3.2, topY: 9 }, ]; for (let i = 0; i < megaBoulders.length; i++) { const mb = megaBoulders[i]; const seed = 700 + i * 17.7; const mat = maybeCracked(seed); const mat2 = pickMat(seed + 1); const mat3 = maybeCracked(seed + 3); const r = mb.r; const baseY = (i === 4) ? 4 : 1; // boulder 4 is partially submerged // Main mass — big box, rotated p.box(api, 'mega-' + i, mb.x - r, baseY, mb.z - r, mb.x + r, mb.topY, mb.z + r, mat, { parent: P, rotation: natRot(seed) }); // Rounded top — large sphere cut p.sphere(api, 'mega-sph-' + i, mb.x, mb.topY - r * 0.3, mb.z, r * 0.85, mat2, { parent: P }); // Chunky side mass p.box(api, 'mega-side-' + i, mb.x + r * 0.3, baseY + 1, mb.z - r * 0.8, mb.x + r * 1.2, mb.topY - 1, mb.z + r * 0.3, mat3, { parent: P, rotation: natRot(seed + 2) }); // Small rock detail on top p.cyl(api, 'mega-det-' + i, mb.x + hashRange(seed + 10, -r * 0.3, r * 0.3), mb.topY - 0.3, mb.z + hashRange(seed + 11, -r * 0.3, r * 0.3), hashRange(seed + 12, 0.5, 1.2), mb.topY + hashRange(seed + 13, 0.3, 1.5), pickMat(seed + 5), 5, { parent: P, rotation: natRot(seed + 4) }); } // ═══════════════════════════════════════ // 7. VOLCANIC ARCH — between pillar field and spine // Center around (40, -125), 20m tall, 30m span // ═══════════════════════════════════════ const archCx = 35, archCz = -125; const archSpan = 30; const archH = 22; const archThick = 2.5; // Left leg (massive rock pillar) p.box(api, 'arch-legL', archCx - archSpan / 2 - 3, 0, archCz - 3, archCx - archSpan / 2 + 2, archH - 3, archCz + 3, BASALT, { parent: P, rotation: { yaw: 3, pitch: -2, roll: 1 } }); p.frustum(api, 'arch-legL-base', archCx - archSpan / 2, 0, archCz, 5, 3.5, 5, DARK_STONE, { parent: P }); p.box(api, 'arch-legL-out', archCx - archSpan / 2 - 4, 3, archCz - 2, archCx - archSpan / 2 - 1, archH * 0.6, archCz + 2.5, CHARCOAL, { parent: P, rotation: natRot(800) }); // Right leg p.box(api, 'arch-legR', archCx + archSpan / 2 - 2, 0, archCz - 3.5, archCx + archSpan / 2 + 3, archH - 2, archCz + 2.5, OBSIDIAN, { parent: P, rotation: { yaw: -4, pitch: 1, roll: -2 } }); p.frustum(api, 'arch-legR-base', archCx + archSpan / 2, 0, archCz, 5.5, 3, 5, DARK_STONE, { parent: P }); p.box(api, 'arch-legR-out', archCx + archSpan / 2 + 1, 2, archCz - 1.5, archCx + archSpan / 2 + 4, archH * 0.5, archCz + 3, BASALT, { parent: P, rotation: natRot(810) }); // Arch span — series of overlapping boxes forming the curved top const archSegs = 10; for (let i = 0; i <= archSegs; i++) { const t = i / archSegs; const ax = archCx - archSpan / 2 + archSpan * t; const ay = archH - 3 + Math.sin(t * Math.PI) * 5; // curved top const aw = archSpan / archSegs * 0.7; // overlap const mat = maybeCracked(820 + i * 7); p.box(api, 'arch-span-' + i, ax - aw, ay - archThick, archCz - archThick, ax + aw, ay + 0.5, archCz + archThick, mat, { parent: P, rotation: natRot(820 + i * 3) }); } // Climbing ledges on left leg (4 ledges spiraling up) for (let i = 0; i < 5; i++) { const ly = 3 + i * 3.5; const side = (i % 2 === 0) ? -1 : 1; const lx = archCx - archSpan / 2 + side * hashRange(830 + i, 1.5, 3.5); p.box(api, 'arch-ledge-L-' + i, lx - 1, ly, archCz + hashRange(831 + i, -2, 1.5), lx + 1.2, ly + 0.5, archCz + hashRange(832 + i, 0.5, 3), pickMat(830 + i), { parent: P }); } // Climbing ledges on right leg for (let i = 0; i < 5; i++) { const ly = 2.5 + i * 3.2; const side = (i % 2 === 0) ? 1 : -1; const lx = archCx + archSpan / 2 + side * hashRange(840 + i, 1, 3); p.box(api, 'arch-ledge-R-' + i, lx - 1.2, ly, archCz + hashRange(841 + i, -2.5, 1), lx + 1, ly + 0.5, archCz + hashRange(842 + i, 0, 2.5), pickMat(840 + i), { parent: P }); } // Top of arch — walkable surface with rough detail p.box(api, 'arch-top-walk', archCx - 4, archH + 1.5, archCz - 2.5, archCx + 4, archH + 2.2, archCz + 2.5, CRACKED, { parent: P, rotation: natRot(850) }); // ═══════════════════════════════════════ // EXTRA: Connecting path rocks between sections // ═══════════════════════════════════════ // From stepping stones to bridge start buildRock(api, 'conn-1', -2, 2, -55, 2.0, 7.8, 900, P); // From bridge end toward island chain buildRock(api, 'conn-2', -40, 2, -92, 2.5, 8.5, 910, P); buildRock(api, 'conn-3', -38, 2, -60, 2.2, 7.5, 920, P); // From stepping stones toward pillar field buildRock(api, 'conn-4', 15, 2, -45, 2.3, 8.0, 930, P); buildRock(api, 'conn-5', 28, 2, -42, 2.0, 8.5, 940, P); buildRock(api, 'conn-6', 37, 2, -40, 1.8, 9.0, 950, P); // From pillar field toward arch buildRock(api, 'conn-7', 50, 2, -105, 2.5, 8.0, 960, P); buildRock(api, 'conn-8', 42, 2, -115, 2.2, 8.5, 970, P); // From arch toward spine buildRock(api, 'conn-9', 30, 2, -138, 2.0, 8.0, 980, P); buildRock(api, 'conn-10', 20, 2, -148, 2.3, 7.5, 990, P); buildRock(api, 'conn-11', 5, 2, -150, 1.8, 8.5, 1000, P); // From island chain toward spine buildRock(api, 'conn-12', -55, 2, -130, 2.5, 9.0, 1010, P); buildRock(api, 'conn-13', -40, 2, -145, 2.0, 8.0, 1020, P); buildRock(api, 'conn-14', -25, 2, -155, 2.2, 8.5, 1030, P); // ═══════════════════════════════════════ // EXTRA: Lava-level detail rocks (barely above lava, decoration) // ═══════════════════════════════════════ const lavaRocks = [ { x: 12, z: -30 }, { x: -18, z: -50 }, { x: 30, z: -70 }, { x: -10, z: -100 }, { x: 60, z: -35 }, { x: -50, z: -55 }, { x: 25, z: -90 }, { x: -35, z: -110 }, { x: 45, z: -115 }, { x: -70, z: -85 }, { x: 15, z: -75 }, { x: -20, z: -130 }, { x: 65, z: -100 }, { x: -45, z: -150 }, { x: 40, z: -155 }, ]; for (let i = 0; i < lavaRocks.length; i++) { const lr = lavaRocks[i]; const r = hashRange(1100 + i * 13, 1.0, 2.5); const topY = hashRange(1100 + i * 17, 5.5, 7.0); // just above or at lava level const mat = (hash(1100 + i * 7) < 0.4) ? CRACKED_HOT : pickMat(1100 + i); p.cyl(api, 'lava-rock-' + i, lr.x, 1, lr.z, r, topY, mat, 5, { parent: P, rotation: natRot(1100 + i * 3) }); } }