// Mini-golf ball — the ONLY player behavior // Handles: aiming, charging, shooting, rolling physics, wall bounces, // sand/water hazards, hole detection, level building, level progression const { LEVELS } = require('lib/levels.js'); const { normalize, distance, length, dot, sub, scale } = require('builtin/vec3'); // ── CONSTANTS ── const BALL_RADIUS = 0.6; const BALL_Y = BALL_RADIUS; // feetPosition y so ball sits on ground const FRICTION = 0.985; // per-frame velocity multiplier const SAND_FRICTION = 0.93; // much more friction on sand const BOUNCE_ENERGY = 0.65; // velocity retained after wall bounce const STOP_THRESHOLD = 0.05; // speed below which ball stops const HOLE_RADIUS = 0.4; // capture radius for the hole const HOLE_SPEED_MAX = 3.0; // max speed to enter hole const MIN_SHOT_SPEED = 5; // minimum impulse speed const MAX_SHOT_SPEED = 25; // maximum impulse speed const POWER_INCREMENT = 0.025; // power charge per input tick const SINK_DURATION = 0.5; // seconds to animate sinking const LEVEL_COMPLETE_DELAY = 2.5; // seconds before advancing const AIM_LINE_LENGTH = 2.5; // base aim line length const AIM_LINE_CHARGE_MAX = 5.0; // aim line length at full charge const TOTAL_LEVELS = 3; // Tags to exclude from wall raycasts const RAYCAST_EXCLUDE = ["ground", "sand-zone", "water-zone", "hole-zone", "fairway", "decoration", "aim-line"]; // ── LIFECYCLE ── export function onSpawn(api) { // Spawn the aim-direction line (client-side visual) const aimId = api.uniqueId("aim-line"); api.spawn(aimId, { tags: ["aim-line"], realm: "client", audience: "local", properties: { primitive: { kind: "cylinder", radiusTop: 0.03, radiusBottom: 0.03, height: AIM_LINE_LENGTH }, material: { color: "oklch(0.95 0.0 0 / 0.6)", emissive: "oklch(0.95 0.0 0)", emissiveIntensity: 0.3 }, feetPosition: { x: 0, y: 0.08, z: 0 }, visible: false } }); api.patchState({ aimLineId: aimId }); // Build the first level buildLevel(1, api); } export function onDestroy(api) { const s = api.getState(); if (s.aimLineId) api.destroy(s.aimLineId); } // ── UPDATE LOOP ── export function update(dt, api) { const s = api.getState(); // Decrement message timer if (s.messageTimer > 0) { const mt = s.messageTimer - dt; if (mt <= 0) { api.patchState({ messageTimer: 0, showMessage: "" }); } else { api.patchState({ messageTimer: mt }); } } if (s.phase === "rolling") { updateRolling(dt, api, s); } else if (s.phase === "sinking") { updateSinking(dt, api, s); } else if (s.phase === "levelComplete") { updateLevelComplete(dt, api, s); } else if (s.phase === "gameWon") { // Just sit there — UI shows final score } // Update aim line visual updateAimLine(api); } // ── ROLLING PHYSICS ── function updateRolling(dt, api, s) { let vx = s.vx; let vz = s.vz; const speed = Math.hypot(vx, vz); if (speed < STOP_THRESHOLD) { api.patchState({ vx: 0, vz: 0, phase: "aiming", canShoot: true }); return; } const pos = api.getProperty("feetPosition"); const moveDistThisFrame = speed * dt; // ── Wall bounce via raycast ── const dirN = normalize({ x: vx, y: 0, z: vz }); const origin = { x: pos.x, y: BALL_Y, z: pos.z }; const hit = api.raycastPhysics(origin, dirN, { maxDistance: moveDistThisFrame + BALL_RADIUS + 0.05, ignoreIds: [api.id], excludeTags: RAYCAST_EXCLUDE }); if (hit && hit.distance < moveDistThisFrame + BALL_RADIUS + 0.05) { // Reflect velocity: v' = v - 2(v·n)n const n = { x: hit.normal.x, y: 0, z: hit.normal.z }; const nLen = Math.hypot(n.x, n.z); if (nLen > 0.001) { const nn = { x: n.x / nLen, y: 0, z: n.z / nLen }; const dotVN = vx * nn.x + vz * nn.z; vx = (vx - 2 * dotVN * nn.x) * BOUNCE_ENERGY; vz = (vz - 2 * dotVN * nn.z) * BOUNCE_ENERGY; // Place ball at bounce point, pulled back slightly const bx = hit.position.x + nn.x * (BALL_RADIUS + 0.02); const bz = hit.position.z + nn.z * (BALL_RADIUS + 0.02); api.setProperty("feetPosition", { x: bx, y: BALL_Y, z: bz }); api.playSound("cdn/sfx-ball-bounce-rubber-wall.mp3", { position: { x: bx, y: 0.2, z: bz }, volume: 0.4 }); api.patchState({ vx, vz }); return; } } // ── Move the ball ── const newX = pos.x + vx * dt; const newZ = pos.z + vz * dt; api.setProperty("feetPosition", { x: newX, y: BALL_Y, z: newZ }); // ── Check sand ── let onSand = false; const sandZones = api.query({ tags: ["sand-zone"], radius: 20 }); for (const sz of sandZones) { const sdist = Math.hypot(newX - sz.feetPosition.x, newZ - sz.feetPosition.z); const sRadius = sz.state.radius || 1.5; if (sdist < sRadius) { onSand = true; break; } } // ── Apply friction ── const fric = onSand ? SAND_FRICTION : FRICTION; vx *= fric; vz *= fric; // ── Check water ── const waterZones = api.query({ tags: ["water-zone"], radius: 30 }); for (const wz of waterZones) { const ws = wz.state; const halfW = (ws.width || 5) / 2; const halfD = (ws.depth || 4) / 2; const wx = wz.feetPosition.x; const wZpos = wz.feetPosition.z; if (newX > wx - halfW && newX < wx + halfW && newZ > wZpos - halfD && newZ < wZpos + halfD) { // Water! Reset ball, +1 penalty stroke const levelData = LEVELS[s.currentLevel]; api.setProperty("feetPosition", { x: levelData.startPos.x, y: BALL_Y, z: levelData.startPos.z }); const newStrokes = s.strokes + 1; api.patchState({ vx: 0, vz: 0, phase: "aiming", canShoot: true, strokes: newStrokes, totalStrokes: s.totalStrokes + 1, showMessage: "Water! +1 stroke", messageTimer: 2 }); api.playSound("cdn/sfx-water-splash-small-puddle.mp3", { position: { x: newX, y: 0.2, z: newZ }, volume: 0.6 }); api.particleBurst({ x: newX, y: 0.1, z: newZ }, "splash", { scale: 0.6, color: "oklch(0.6 0.15 230)" }); return; } } // ── Check hole ── const holeX = s.holePos.x; const holeZ = s.holePos.z; const holeDist = Math.hypot(newX - holeX, newZ - holeZ); const curSpeed = Math.hypot(vx, vz); if (holeDist < HOLE_RADIUS && curSpeed < HOLE_SPEED_MAX) { // Ball sinks in! api.patchState({ vx: 0, vz: 0, phase: "sinking", sinkTimer: 0 }); api.playSound("cdn/sfx-golf-ball-drop-into-hole-cup.mp3", { position: { x: holeX, y: 0.1, z: holeZ }, volume: 0.7 }); api.particleBurst({ x: holeX, y: 0.1, z: holeZ }, "sparkle", { scale: 0.5, color: "oklch(0.85 0.18 95)" }); return; } api.patchState({ vx, vz }); } // ── SINKING ANIMATION ── function updateSinking(dt, api, s) { const timer = (s.sinkTimer || 0) + dt; const t = Math.min(timer / SINK_DURATION, 1); // Move toward hole center and shrink const pos = api.getProperty("feetPosition"); const hx = s.holePos.x; const hz = s.holePos.z; const nx = pos.x + (hx - pos.x) * 0.2; const nz = pos.z + (hz - pos.z) * 0.2; const newY = BALL_Y * (1 - t * 0.8); api.setProperty("feetPosition", { x: nx, y: newY, z: nz }); api.setProperty("scale", { x: 1 - t * 0.6, y: 1 - t * 0.6, z: 1 - t * 0.6 }); if (t >= 1) { // Sinking complete api.setProperty("scale", 1); const strokes = s.strokes; const parArr = s.par || [2, 3, 4]; const par = parArr[s.currentLevel - 1] || 2; let scoreText = ""; const diff = strokes - par; if (diff <= -2) scoreText = "Eagle!"; else if (diff === -1) scoreText = "Birdie!"; else if (diff === 0) scoreText = "Par!"; else if (diff === 1) scoreText = "Bogey"; else scoreText = "+" + diff; if (s.currentLevel < TOTAL_LEVELS) { api.patchState({ phase: "levelComplete", levelCompleteTimer: 0, sinkTimer: 0, showMessage: "Hole " + s.currentLevel + " complete! " + strokes + " strokes (" + scoreText + ")", messageTimer: LEVEL_COMPLETE_DELAY }); api.announce("Hole in " + strokes + "! " + scoreText, { style: "info", duration: 2.5 }); } else { // Game won! const totalStrokes = s.totalStrokes + strokes; const spl = [...(s.strokesPerLevel || [0, 0, 0])]; spl[s.currentLevel - 1] = strokes; const totalPar = 2 + 3 + 4; // 9 const finalDiff = totalStrokes - totalPar; const finalText = finalDiff <= 0 ? (finalDiff === 0 ? "Even par!" : finalDiff + " under par!") : "+" + finalDiff + " over par"; api.patchState({ phase: "gameWon", sinkTimer: 0, strokes: strokes, totalStrokes: totalStrokes, strokesPerLevel: spl, showMessage: "Course complete! Total: " + totalStrokes + " (" + finalText + ")", messageTimer: 999 }); api.announce("Course Complete! " + totalStrokes + " strokes — " + finalText, { style: "discovery", duration: 5 }); } } else { api.patchState({ sinkTimer: timer }); } } // ── LEVEL COMPLETE WAIT ── function updateLevelComplete(dt, api, s) { const timer = (s.levelCompleteTimer || 0) + dt; if (timer >= LEVEL_COMPLETE_DELAY) { advanceLevel(api); } else { api.patchState({ levelCompleteTimer: timer }); } } // ── INPUT HANDLING ── export function onInput(input, api) { const s = api.getState(); // Restart current level if (input.actions.restart) { const levelData = LEVELS[s.currentLevel]; api.setProperty("feetPosition", { x: levelData.startPos.x, y: BALL_Y, z: levelData.startPos.z }); api.setProperty("scale", 1); api.patchState({ vx: 0, vz: 0, phase: "aiming", canShoot: true, charging: false, power: 0, strokes: 0 }); return; } // Game won → restart all if (s.phase === "gameWon" && (input.actions.shoot || input.actions.restart)) { api.patchState({ currentLevel: 1, strokes: 0, totalStrokes: 0, strokesPerLevel: [0, 0, 0], phase: "aiming", canShoot: true, charging: false, power: 0, showMessage: "", messageTimer: 0 }); buildLevel(1, api); return; } if (s.phase !== "aiming" || !s.canShoot) return; // Aim toward pointer — compute direction FROM ball TO cursor in world space if (input.pointer) { // Use getPointerDirection to get a world-space ray from camera through cursor const pointerDir = api.getPointerDirection(input); if (pointerDir) { const cam = api.getCamera(); if (cam) { const pos = api.getProperty("feetPosition"); // Project ray from camera through cursor onto the ground plane (y=0) // Ray: P = cam.position + t * pointerDir // Ground: y = 0 → t = -cam.position.y / pointerDir.y if (Math.abs(pointerDir.y) > 0.001) { const t = -cam.position.y / pointerDir.y; if (t > 0) { const worldX = cam.position.x + t * pointerDir.x; const worldZ = cam.position.z + t * pointerDir.z; // Direction from ball to cursor world position let ax = worldX - pos.x; let az = worldZ - pos.z; const aMag = Math.hypot(ax, az); if (aMag > 0.1) { ax /= aMag; az /= aMag; api.patchState({ aimX: ax, aimZ: az }); } } } } } } // Charging (hold fires every frame while mouse is held) if (input.actions.charge) { const newPower = Math.min(1.0, (s.power || 0) + POWER_INCREMENT); api.patchState({ charging: true, power: newPower }); } // Shoot (mouse release) — use re-read state to avoid race condition with charge if (input.actions.shoot) { const current = api.getState(); // Allow shot if we were charging OR if charge+shoot fired same frame if (current.charging || input.actions.charge) { const power = Math.max(current.power || 0, POWER_INCREMENT); const shotSpeed = MIN_SHOT_SPEED + power * (MAX_SHOT_SPEED - MIN_SHOT_SPEED); const ax = current.aimX || 0; const az = current.aimZ || -1; const strokes = (current.strokes || 0) + 1; api.patchState({ vx: ax * shotSpeed, vz: az * shotSpeed, phase: "rolling", canShoot: false, charging: false, power: 0, strokes: strokes, totalStrokes: (current.totalStrokes || 0) + 1 }); api.playSound("cdn/sfx-golf-club-hit-ball-whack.mp3", { volume: 0.6 }); } } } // ── AIM LINE VISUAL ── function updateAimLine(api) { const s = api.getState(); const aimId = s.aimLineId; if (!aimId) return; const isAiming = s.phase === "aiming" && s.canShoot; api.setObjectProperty(aimId, "visible", isAiming); if (!isAiming) return; const pos = api.getProperty("feetPosition"); const ax = s.aimX || 0; const az = s.aimZ || -1; const charging = s.charging; const power = s.power || 0; // Length based on charge const lineLen = charging ? AIM_LINE_LENGTH + power * (AIM_LINE_CHARGE_MAX - AIM_LINE_LENGTH) : AIM_LINE_LENGTH; const halfLen = lineLen / 2; // Position: center of the line, offset from ball in aim direction const cx = pos.x + ax * (halfLen + BALL_RADIUS + 0.1); const cz = pos.z + az * (halfLen + BALL_RADIUS + 0.1); api.setObjectProperty(aimId, "feetPosition", { x: cx, y: 0.08, z: cz }); api.setObjectProperty(aimId, "primitive", { kind: "cylinder", radiusTop: 0.025, radiusBottom: 0.025, height: lineLen }); // Orient the cylinder along the aim direction // Cylinder default axis is Y. We want it along the XZ aim direction. const dir3 = { x: ax, y: 0, z: az }; const rot = api.rotationFromDirection(dir3, "y"); api.setObjectProperty(aimId, "rotation", rot); // Color: brighter when charging if (charging) { const r = 0.7 + power * 0.3; api.setObjectProperty(aimId, "material", { color: "oklch(0.95 0.15 60 / 0.9)", emissive: "oklch(0.95 0.15 60)", emissiveIntensity: 0.5 + power * 0.8 }); } else { api.setObjectProperty(aimId, "material", { color: "oklch(0.95 0.0 0 / 0.5)", emissive: "oklch(0.95 0.0 0)", emissiveIntensity: 0.2 }); } } // ── BUILD LEVEL ── function buildLevel(level, api) { // Destroy old level geometry const oldGeo = api.query({ tags: ["level-geo"], radius: 200 }); for (const obj of oldGeo) { api.destroy(obj.id); } const data = LEVELS[level]; if (!data) { api.error("No level data for level " + level); return; } // ── Fairways ── for (let i = 0; i < data.fairways.length; i++) { const fw = data.fairways[i]; api.spawn(api.uniqueId("fairway"), { tags: ["level-geo", "fairway"], properties: { feetPosition: { x: fw.x, y: -0.15, z: fw.z }, primitive: { kind: "box", width: fw.width, height: 0.3, depth: fw.depth }, material: { color: "oklch(0.55 0.15 145)", texture: "/cdn/texture-stylized-grass-green-lawn.png", roughness: 0.9 }, physics: "static" } }); } // ── Walls ── for (let i = 0; i < data.walls.length; i++) { const w = data.walls[i]; const h = w.height || 0.5; api.spawn(api.uniqueId("wall"), { tags: ["level-geo", "wall"], properties: { feetPosition: { x: w.x, y: 0, z: w.z }, primitive: { kind: "box", width: w.width, height: h, depth: w.depth }, material: { color: w.color || "oklch(0.40 0.08 145)", roughness: 0.8 }, physics: "static" } }); } // ── Sand traps ── for (let i = 0; i < data.sandTraps.length; i++) { const st = data.sandTraps[i]; api.spawn(api.uniqueId("sand"), { tags: ["level-geo", "sand-zone"], state: { radius: st.radius }, properties: { feetPosition: { x: st.x, y: 0.01, z: st.z }, primitive: { kind: "cylinder", radius: st.radius, height: 0.05 }, material: { color: "oklch(0.75 0.10 85)", roughness: 1.0 } } }); } // ── Water hazards ── for (let i = 0; i < data.waterHazards.length; i++) { const wh = data.waterHazards[i]; api.spawn(api.uniqueId("water"), { tags: ["level-geo", "water-zone"], state: { width: wh.width, depth: wh.depth }, properties: { feetPosition: { x: wh.x, y: -0.02, z: wh.z }, primitive: { kind: "box", width: wh.width, height: 0.06, depth: wh.depth }, material: { kind: "water", color: "oklch(0.55 0.15 240)", opacity: 0.8 } } }); } // ── Hole ── api.spawn(api.uniqueId("hole"), { tags: ["level-geo", "hole-zone"], properties: { feetPosition: { x: data.holePos.x, y: -0.05, z: data.holePos.z }, primitive: { kind: "cylinder", radius: 0.35, height: 0.1 }, material: { color: "oklch(0.15 0.0 0)", roughness: 1.0 } } }); // ── Flag ── // Pole api.spawn(api.uniqueId("flag-pole"), { tags: ["level-geo", "decoration"], properties: { feetPosition: { x: data.holePos.x, y: 0, z: data.holePos.z }, primitive: { kind: "cylinder", radiusTop: 0.03, radiusBottom: 0.03, height: 1.8 }, material: { color: "oklch(0.90 0.0 0)", roughness: 0.5 } } }); // Flag cloth api.spawn(api.uniqueId("flag-cloth"), { tags: ["level-geo", "decoration"], properties: { feetPosition: { x: data.holePos.x + 0.25, y: 1.5, z: data.holePos.z }, primitive: { kind: "box", width: 0.45, height: 0.3, depth: 0.05 }, material: { color: "oklch(0.60 0.25 25)", emissive: "oklch(0.60 0.25 25)", emissiveIntensity: 0.2 } } }); // ── Decorations ── for (let i = 0; i < data.decorations.length; i++) { const dec = data.decorations[i]; if (dec.type === "flower") { api.spawn(api.uniqueId("flower"), { tags: ["level-geo", "decoration"], properties: { feetPosition: { x: dec.x, y: 0, z: dec.z }, model: "/cdn/model-stylized-flower-tulip-red.glb", scale: 0.6 } }); } } // ── Set ball position ── api.setProperty("feetPosition", { x: data.startPos.x, y: BALL_Y, z: data.startPos.z }); api.setProperty("scale", 1); // ── Update state ── api.patchState({ currentLevel: level, holePos: { x: data.holePos.x, z: data.holePos.z }, levelName: data.name, par: [LEVELS[1].par, LEVELS[2].par, LEVELS[3].par], vx: 0, vz: 0, phase: "aiming", canShoot: true, charging: false, power: 0, showMessage: "Hole " + level + ": " + data.name + " (Par " + data.par + ")", messageTimer: 3 }); if (level === 1) { api.announce(data.name + " — Par " + data.par, { style: "info", duration: 2.5 }); } else { api.announce("Hole " + level + ": " + data.name + " — Par " + data.par, { style: "info", duration: 2.5 }); } } // ── ADVANCE LEVEL ── function advanceLevel(api) { const s = api.getState(); const spl = [...(s.strokesPerLevel || [0, 0, 0])]; spl[s.currentLevel - 1] = s.strokes; const nextLevel = s.currentLevel + 1; api.patchState({ strokesPerLevel: spl, currentLevel: nextLevel, strokes: 0, phase: "aiming", canShoot: true, showMessage: "", messageTimer: 0 }); buildLevel(nextLevel, api); }