// Arcade go-kart — raycast wheels, suspension, weight transfer, handbrake drift. // Tuned for the SuperTuxKart "grip then break loose" feel, not real-world physics. const WHEEL_R = 0.33; const WHEEL_W = 0.26; const HW = 0.58; // wheel X from center const FZ = -0.78; // front axle Z (forward = -Z) const RZ = 0.82; // rear axle Z const RAD2DEG = 180 / Math.PI; const DEG2RAD = Math.PI / 180; // Suspension — real travel so wheels can push, firm enough not to wallow. // Softer + shorter rest so the body sags onto the wheels instead of hovering. const SUSP_REST = 0.27; const SUSP_STIFFNESS = 28; const SUSP_COMPRESSION = 3.0; const SUSP_RELAXATION = 4.0; // Downforce — keeps the kart planted and brings it back down off jumps const DOWNFORCE_SPEED = 2.3; // grows with speed (planted cornering) — higher = harder to tip in a hard turn const DOWNFORCE_AIR = 6.5; // m/s^2 extra pull-down when no wheels touch (eased so jumps have hang time to steer) // Air control — while airborne the player can swing the nose and tuck/pull, and // the kart drifts gently back toward flat so a jump can be landed on its wheels. const AIR_YAW_RATE = 2.6; // rad/s — left/right to aim the landing const AIR_PITCH_RATE = 2.2; // rad/s — forward = nose down, back = nose up const AIR_LEVEL_RATE = 1.7; // rad/s — passive self-righting toward world-up const AIR_ENGAGE = 0.22; // s fully off the ground before air control wakes — filters out hard-turn wheel lift // Stunt records — longest jump (distance cleared) + longest wheelie (time held) const MIN_JUMP_DIST = 7; // m of horizontal travel before a hop counts as a jump const MIN_JUMP_RISE = 0.7; // m the kart must rise off takeoff to count (clears a real ramp, not a bump) const MIN_WHEELIE_T = 1.0; // s on the back wheels before it counts as a wheelie // Drive const DRIVE_FORCE = 230; // softened so the nose only pops on real launches, not every tap const PAD_BOOST_MULT = 1.10; // boost-strip: +10% drive force AND top-speed ceiling, ~2s const REVERSE_FORCE = 160; const BRAKE_FORCE = 12; const ENGINE_BRAKE = 3.2; const TOP_SPEED = 23.6; // m/s soft cap (~85 km/h on the dash) — trimmed 15% for control // --- Loop-the-loop --- // A vertical loop you can only complete with speed. Pure raycast suspension // can't carry a kart upside down, so when a fast kart crosses the loop's base // moving the right way we hand it a scripted "loop lock": override position + // rotation around the circle for a beat, then fling it out the far side still // rolling. Too slow at the base = you just drive straight through (no lock). const LOOP = { x: -4, z: -52, R: 7, halfW: 4.6, gapDeg: 16, legLen: 9, off: true }; const LOOP_SPEED_GATE = 11; // m/s needed at the ramp to catch the lock const LOOP_DUR = 1.7; // seconds: ramp-in + full loop + ramp-out // Phase split of the ride (fractions of LOOP_DUR) const LOOP_P1 = 0.17, LOOP_P2 = 0.66; // lead-in, then loop; remainder = lead-out // Per-style handling personality. The body you pick now drives differently — // multipliers layer over the shared physics so each kart keeps the same feel // family but with its own character. // accel = how hard it pulls top = top-speed ceiling // brake = stopping power steer = how sharp it turns // grip = rear grip (low = loose, slidey tail) // BUGGY is the baseline — its planted, smooth feel is the gold standard. Every // kart now lives in the buggy's handling family (steer ~0.82-0.86, grip ~1.2); // they differ in power, top speed and brakes, NOT in twitchiness. const STYLES = { buggy: { accel: 0.90, top: 0.92, brake: 1.25, steer: 0.82, grip: 1.25 }, // the baseline — glued down, stops on a dime classic: { accel: 1.00, top: 1.00, brake: 1.05, steer: 0.86, grip: 1.18 }, // balanced all-rounder, a hair quicker turn f1: { accel: 1.14, top: 1.10, brake: 1.15, steer: 0.86, grip: 1.20 }, // fastest + strong brakes, but turns like the buggy family now hotrod: { accel: 1.22, top: 1.05, brake: 0.85, steer: 0.84, grip: 0.95 }, // brutal launch, looser tail, weak brakes — power over grip }; function styleTune(s) { return STYLES[(s && s.kartStyle) || "classic"] || STYLES.classic; } // Steering (speed-sensitive) const STEER_MAX = Math.PI / 10.5; const STEER_MIN = Math.PI / 16; const STEER_SPEED_FACTOR = 0.07; const STEER_LERP = 0.22; // Grip / drift const GRIP = 7.5; const DRIFT_REAR = 3.1; // rear grip while carving — looser so it can whip around into fuller spins const DRIFT_HOLD = 4.2; const HANDBRAKE_REAR = 1.2; // --- SuperTuxKart carve --- // Tap drift → little hop to break traction, lock a direction, then carve a // TIGHTER arc than normal steering allows. The longer you hold, the bigger the // release boost. Steering into the skid tightens; counter-steer widens it. const HOP_IMPULSE = 200; // upward pop on engage (impulse, ~2.9 m/s — a visible little hop) const SKID_TURN_BASE = 0.8; // carve arc opened up — softer, sweeping drift, not a snap const SKID_TURN_MOD = 0.34; // how much player steer tightens/widens the carve const SKID_RAMP = 0.3; // seconds to ramp from normal turn into full carve const DRIFT_DOWNFORCE = 13; // planted — hold the line through a long carve without rolling const DRIFT_THROTTLE = 0.85; // fraction of drive force kept while drifting — holds speed through the slide const VISUAL_SKID_MAX = 24; // degrees the body yaws into the slide (graphics only, physics unaffected) const VISUAL_SKID_LERP = 0.16; // how fast the body swings into / out of the lean // --- Weapons --- // The punch: a boxing glove on a spring that thunks forward off the nose and // launches whoever's in front. One-shot — grab a box, throw a punch, it's spent. const PUNCH_REACH = 6.6; // m in front the fist can connect const PUNCH_CONE = 0.5; // forward-cone tightness (dot threshold; lower = wider arc) const PUNCH_DMG = 30; // ~a third of a kart's health const BANANA_SLOW_MULT = 0.42; // top-speed + force multiplier while a banana slip is bogging you down // --- Bumper contact: ramming another racer at speed knocks them loose --- const RAM_REACH = 2.4; // m between kart centers to count as a body slam const RAM_MIN_SPEED = 9; // m/s — you have to be moving with intent, not nudging const RAM_CLOSING = 5; // m/s of closing speed along the contact axis to trigger const RAM_DMG = 18; // lighter than a punch — bumps chip, punches finish const RAM_RECOIL = 70; // how hard the rammer bounces back off the hit const RAM_CD = 0.9; // seconds between your own rams (no machine-gun bumping) // Frame pacing: proximity scans are cached/staggered; live positions are still // re-read from object ids every tick so hits don't use stale coordinates. const RAM_SCAN_TICKS = 3; const RAM_SCAN_PAD = 5.0; const AI_HUNT_SCAN_TICKS = 6; const ENGINE_PARAM_TICKS = 2; const DEBRIS_SPAWN_CAP = 2; function hashStringId(id) { const str = String(id || ""); let h = 0; for (let i = 0; i < str.length; i++) h = (h * 31 + str.charCodeAt(i)) & 0xffff; return h; } function staggerOffset(id, interval) { return interval > 1 ? hashStringId(id) % interval : 0; } // Deterministic [0,1) stream from a seed. Used for hit-launch jitter so every // client and the server compute the SAME tumble from the same shared hit — a // per-client Math/objectApi.random() here desyncs the kart's flight permanently // (physics is chaotic; the error never reconciles back). function seededUnit(seed, n) { let h = (Math.floor(seed * 100003) ^ (n * 374761393)) >>> 0; h = Math.imul(h ^ (h >>> 15), 2246822519) >>> 0; h = Math.imul(h ^ (h >>> 13), 3266489917) >>> 0; return ((h ^ (h >>> 16)) >>> 0) / 4294967296; } function queryDrivableIds(objectApi, radius) { const near = objectApi.query({ tags: ["drivable"], radius }) || []; const ids = []; for (let i = 0; i < near.length; i++) if (near[i].id && near[i].id !== objectApi.id) ids.push(near[i].id); return ids; } function liveDrivableSnapshot(objectApi, id) { const state = objectApi.getObjectState(id) || {}; const feetPosition = objectApi.getObjectProperty(id, "feetPosition"); return feetPosition ? { id, state, feetPosition } : null; } // Parts that can rattle loose in a hard spinout (each is its own primitive). const MAT_WHEEL = { color: "oklch(0.16 0.01 0)", roughness: 0.95 }; const MAT_CHRM = { color: "oklch(0.75 0 0)", roughness: 0.15, metalness: 0.8 }; const MAT_RED = { color: "oklch(0.58 0.22 28)", roughness: 0.4 }; const MAT_YEL = { color: "oklch(0.82 0.18 95)", roughness: 0.4 }; // Each part has a health threshold: it rattles loose when health drops below it // and pops back on once health climbs back over it. Ordered worst-first so the // damage reads at a glance — rear wing goes first, last tire goes last. const DETACHABLE = [ { suffix: "wing", threshold: 90, prim: { kind: "box", width: 0.84, height: 0.06, depth: 0.13 }, mat: MAT_RED, body: true }, { suffix: "wheel-0", threshold: 70, prim: { kind: "cylinder", radius: WHEEL_R, height: WHEEL_W }, mat: MAT_WHEEL }, { suffix: "fbar", threshold: 55, prim: { kind: "box", width: 1.0, height: 0.06, depth: 0.06 }, mat: MAT_CHRM }, { suffix: "nose-tip", threshold: 40, prim: { kind: "box", width: 0.44, height: 0.14, depth: 0.12 }, mat: MAT_YEL }, { suffix: "wheel-1", threshold: 25, prim: { kind: "cylinder", radius: WHEEL_R, height: WHEEL_W }, mat: MAT_WHEEL }, ]; const COUNTER_GRIP = 9; // Nitro const NITRO_MULT = 1.7; const NITRO_MAX = 2.4; const NITRO_RECHARGE = 0.35; // CTR-style power-slide boost — hold the drift to charge the exhaust through // color stages, release to fire a turbo. Chargeable while sliding at speed. const DRIFT_STAGE1 = 0.6; // sparks (yellow) const DRIFT_STAGE2 = 1.4; // flames (orange) const DRIFT_STAGE3 = 2.3; // turbo (blue) const BOOST_IMPULSE = [0, 130, 220, 340]; // forward kick by stage const WHEELS = [ { x: -HW, y: 0, z: FZ }, { x: HW, y: 0, z: FZ }, { x: -HW, y: 0, z: RZ }, { x: HW, y: 0, z: RZ }, ]; const SEAT_LOCAL_POS = { x: 0, y: 0.42, z: 0.15 }; // ---- wheel math (copied exact from vehicles skill) ---- function quatMul(a, b) { return { x: a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y, y: a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x, z: a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w, w: a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z, }; } function quatFromAxisAngle(ax, ay, az, angle) { const half = angle * 0.5; const s = Math.sin(half); return { x: ax * s, y: ay * s, z: az * s, w: Math.cos(half) }; } function wheelWidthAxis(rotation) { const yaw = (rotation.yaw ?? 0) * DEG2RAD; const roll = (rotation.roll ?? 0) * DEG2RAD; const qYaw = quatFromAxisAngle(0, 1, 0, yaw); const qRoll = quatFromAxisAngle(0, 0, 1, roll); const q = quatMul(qYaw, qRoll); return { x: 2 * (q.x * q.y - q.w * q.z), y: 1 - 2 * (q.x * q.x + q.z * q.z), z: 2 * (q.y * q.z + q.w * q.x), }; } function feetFromCenterAlongUp(center, up, halfUpExtent) { return { x: center.x - halfUpExtent * up.x, y: center.y - halfUpExtent * up.y, z: center.z - halfUpExtent * up.z, }; } function wheelFeetFromCenter(center, rotation) { return feetFromCenterAlongUp(center, wheelWidthAxis(rotation), WHEEL_W * 0.5); } function rotateVec3ByQuat(x, y, z, q) { const ix = q.w * x + q.y * z - q.z * y; const iy = q.w * y + q.z * x - q.x * z; const iz = q.w * z + q.x * y - q.y * x; const iw = -q.x * x - q.y * y - q.z * z; return { x: ix * q.w + iw * -q.x + iy * -q.z - iz * -q.y, y: iy * q.w + iw * -q.y + iz * -q.x - ix * -q.z, z: iz * q.w + iw * -q.z + ix * -q.y - iy * -q.x, }; } function quatYaw(deg) { const half = deg * DEG2RAD * 0.5; return { x: 0, y: Math.sin(half), z: 0, w: Math.cos(half) }; } function slerpQuat(a, b, t) { let d = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; let bx = b.x, by = b.y, bz = b.z, bw = b.w; if (d < 0) { d = -d; bx = -bx; by = -by; bz = -bz; bw = -bw; } if (d > 0.9995) { const x = a.x + (bx - a.x) * t, y = a.y + (by - a.y) * t, z = a.z + (bz - a.z) * t, w = a.w + (bw - a.w) * t; const l = Math.hypot(x, y, z, w) || 1; return { x: x / l, y: y / l, z: z / l, w: w / l }; } const th = Math.acos(d), s = Math.sin(th); const wa = Math.sin((1 - t) * th) / s, wb = Math.sin(t * th) / s; return { x: a.x * wa + bx * wb, y: a.y * wa + by * wb, z: a.z * wa + bz * wb, w: a.w * wa + bw * wb }; } function box(api, id, x0, y0, z0, x1, y1, z1, mat, opts) { api.spawn(id, { parent: opts.parent, properties: { feetPosition: { x: (x0 + x1) / 2, y: y0, z: (z0 + z1) / 2 }, primitive: { kind: "box", width: Math.abs(x1 - x0), height: Math.abs(y1 - y0), depth: Math.abs(z1 - z0) }, material: mat, }, }); } export function onSpawn(objectApi) { objectApi.setProperty("primitive", { kind: "box", width: 1.05, height: 0.32, depth: 1.85 }); objectApi.setProperty("visible", false); // EVERY kart is a permanent, fully-physical vehicle that lives on the grid for // the whole session. No spawn-on-mount / destroy-on-exit churn — that churn left // moving karts briefly un-owned, and an un-owned physics vehicle is simulated // independently by every client (drift at 2 players, total ghosting at 4). A kart // that always exists and always carries its driver's controller stays in sync. // A PARKED kart is dead still, so it can't visibly diverge between screens. objectApi.setProperty("physics", { body: "vehicle", mass: 68, restitution: 0, linearDamping: 0.05, angularDamping: 5.0, wheels: WHEELS.map((w) => ({ position: w, radius: WHEEL_R, suspensionRestLength: SUSP_REST, suspensionStiffness: SUSP_STIFFNESS, suspensionCompression: SUSP_COMPRESSION, suspensionRelaxation: SUSP_RELAXATION, frictionSlip: GRIP, maxSuspensionForce: 6000, })), }); const P = objectApi.id; // Visual shell pivot — all body + wheel parts hang off this node so we can yaw // the whole model (the SuperTuxKart drift "lean") WITHOUT rotating the physics body. const shellId = objectApi.spawn("shell", { parent: P, properties: { feetPosition: { x: 0, y: 0, z: 0 } }, }); // Invisible kart-sized box the shield outline can hug. The shell is an empty // pivot and the body is dozens of tiny panels — the native outline grabs ONE // mesh, so we give it a single hull-shaped proxy to trace. Hidden; the outline // pass clones its geometry regardless of visibility. const outlineProxyId = objectApi.spawn("outline-proxy", { parent: shellId, properties: { feetPosition: { x: 0, y: 0.04, z: -0.05 }, primitive: { kind: "box", width: 1.45, height: 1.0, depth: 2.55 }, visible: false, }, }); objectApi.patchState({ shellId, outlineProxyId }); // Remember where this kart was parked — its grid slot is home. An abandoned // kart returns here. (Instance state survives script reloads, so only the very // first spawn captures it; existing karts keep the home they already have.) if (objectApi.getState().homeX === undefined) { const hf = objectApi.getProperty("feetPosition") || { x: 0, z: 0 }; const hr = objectApi.getProperty("rotation") || {}; objectApi.patchState({ homeX: hf.x, homeZ: hf.z, homeYaw: hr.yaw ?? 180 }); } const O = { parent: shellId, physics: false }; // Body color is per-kart so a starting grid can be a row of different machines. // Defaults to the classic red; spawn with state.bodyColor to repaint the shell. const bodyColor = (objectApi.getState?.() || {}).bodyColor || "oklch(0.58 0.22 28)"; // Each kart wears different bodywork so the grid reads as four distinct // machines, not one kart in four paints. Same chassis underneath. const style = (objectApi.getState?.() || {}).kartStyle || "classic"; const RED = { color: bodyColor, roughness: 0.4 }; const DARK = { color: "oklch(0.2 0.01 0)", roughness: 0.6 }; const YEL = { color: "oklch(0.82 0.18 95)", roughness: 0.4 }; const SEAT = { color: "oklch(0.32 0.05 30)", roughness: 0.7 }; const CHRM = { color: "oklch(0.75 0 0)", roughness: 0.15, metalness: 0.8 }; const GUN = { color: "oklch(0.38 0.01 250)", roughness: 0.45, metalness: 0.6 }; // gunmetal cage/tubes const HEAD = { color: "oklch(0.96 0.04 95)", emissive: "oklch(0.92 0.13 95)", emissiveIntensity: 2.4, roughness: 0.25 }; // headlamps const GLOW = { color: YEL.color, emissive: "oklch(0.85 0.18 95)", emissiveIntensity: 1.6, roughness: 0.3 }; // livery accent glow // Floor pan box(objectApi, "pan", -0.46, 0.06, -0.85, 0.46, 0.12, 0.95, DARK, O); // Side pods box(objectApi, "pod-l", -0.6, 0.1, -0.3, -0.46, 0.34, 0.7, RED, O); box(objectApi, "pod-r", 0.46, 0.1, -0.3, 0.6, 0.34, 0.7, RED, O); // Nose — shape varies per machine. if (style === "f1") { // Long, tapering nose that pinches to a fine tip, then a multi-element front // wing with upswept endplates — pure speed silhouette. box(objectApi, "nose", -0.3, 0.12, -0.95, 0.3, 0.3, -0.55, RED, O); box(objectApi, "nose-mid", -0.2, 0.12, -1.18, 0.2, 0.24, -0.95, RED, O); box(objectApi, "nose-tip", -0.1, 0.13, -1.42, 0.1, 0.2, -1.18, YEL, O); // Front wing: main plane + flap, raised slightly off the deck. box(objectApi, "fwing", -0.56, 0.07, -1.42, 0.56, 0.1, -1.24, DARK, O); box(objectApi, "fflap", -0.56, 0.13, -1.36, 0.56, 0.16, -1.26, GLOW, O); // Upswept endplates that frame the front wing. box(objectApi, "fep-l", -0.58, 0.07, -1.42, -0.52, 0.26, -1.22, CHRM, O); box(objectApi, "fep-r", 0.52, 0.07, -1.42, 0.58, 0.26, -1.22, CHRM, O); // Bargeboards sweeping back from the nose to the sidepods. box(objectApi, "barge-l", -0.48, 0.12, -0.55, -0.42, 0.3, -0.1, GLOW, O); box(objectApi, "barge-r", 0.42, 0.12, -0.55, 0.48, 0.3, -0.1, GLOW, O); } else if (style === "hotrod") { // Stubby wide nose with a hood scoop — muscle up front. box(objectApi, "nose", -0.42, 0.1, -0.95, 0.42, 0.36, -0.5, RED, O); box(objectApi, "nose-tip", -0.34, 0.1, -1.04, 0.34, 0.32, -0.95, YEL, O); box(objectApi, "scoop", -0.18, 0.34, -0.52, 0.18, 0.5, -0.18, DARK, O); box(objectApi, "fbar", -0.52, 0.14, -1.02, 0.52, 0.22, -0.96, CHRM, O); } else if (style === "buggy") { // Chunky high nose, angled skid plate, a tubular brush guard and a winch drum — // built to take a beating off-road. box(objectApi, "nose", -0.36, 0.12, -0.9, 0.36, 0.38, -0.5, RED, O); box(objectApi, "nose-tip", -0.28, 0.14, -0.98, 0.28, 0.34, -0.9, YEL, O); box(objectApi, "skid", -0.34, 0.04, -1.0, 0.34, 0.1, -0.55, GUN, O); // Tubular brush guard wrapping the front. box(objectApi, "bull-bar", -0.5, 0.16, -1.04, 0.5, 0.42, -0.96, GUN, O); box(objectApi, "bull-l", -0.5, 0.16, -1.0, -0.44, 0.42, -0.9, GUN, O); box(objectApi, "bull-r", 0.44, 0.16, -1.0, 0.5, 0.42, -0.9, GUN, O); // Winch drum mounted center. objectApi.spawn("winch", { parent: shellId, properties: { feetPosition: { x: 0, y: 0.22, z: -0.86 }, primitive: { kind: "cylinder", radius: 0.07, height: 0.22 }, rotation: { roll: 90 }, material: GUN }, }); // Two fog lamps low on the bumper. objectApi.spawn("fog-l", { parent: shellId, properties: { feetPosition: { x: -0.22, y: 0.28, z: -1.02 }, primitive: { kind: "cylinder", radius: 0.06, height: 0.05 }, rotation: { pitch: 90 }, material: HEAD }, }); objectApi.spawn("fog-r", { parent: shellId, properties: { feetPosition: { x: 0.22, y: 0.28, z: -1.02 }, primitive: { kind: "cylinder", radius: 0.06, height: 0.05 }, rotation: { pitch: 90 }, material: HEAD }, }); } else { // Classic open-wheel nose cone. box(objectApi, "nose", -0.34, 0.1, -1.0, 0.34, 0.3, -0.55, RED, O); box(objectApi, "nose-tip", -0.22, 0.1, -1.12, 0.22, 0.24, -1.0, YEL, O); box(objectApi, "fbar", -0.5, 0.14, -1.1, 0.5, 0.2, -1.04, CHRM, O); } // Steering column + wheel box(objectApi, "col", -0.04, 0.2, -0.5, 0.04, 0.5, -0.3, DARK, O); objectApi.spawn("steer-wheel", { parent: shellId, properties: { feetPosition: { x: 0, y: 0.5, z: -0.32 }, primitive: { kind: "torus", radius: 0.13, tube: 0.025 }, rotation: { pitch: 65 }, material: DARK, }, }); // Seat box(objectApi, "seat-base", -0.26, 0.12, 0.05, 0.26, 0.22, 0.5, SEAT, O); box(objectApi, "seat-back", -0.26, 0.22, 0.42, 0.26, 0.72, 0.52, SEAT, O); // Top structure — roll hoop, full cage, or stripped low profile. if (style === "buggy") { // Full gunmetal roll cage: front + rear hoops joined by top rails, with // diagonal A-pillar braces and a roof-mounted light bar. objectApi.spawn("cage-rear", { parent: shellId, properties: { feetPosition: { x: 0, y: 0.5, z: 0.6 }, primitive: { kind: "torus", radius: 0.34, tube: 0.05, arc: Math.PI }, material: GUN }, }); objectApi.spawn("cage-front", { parent: shellId, properties: { feetPosition: { x: 0, y: 0.5, z: -0.1 }, primitive: { kind: "torus", radius: 0.34, tube: 0.05, arc: Math.PI }, material: GUN }, }); // Top rails connecting the hoops. box(objectApi, "cage-l", -0.345, 0.8, -0.1, -0.295, 0.85, 0.6, GUN, O); box(objectApi, "cage-r", 0.295, 0.8, -0.1, 0.345, 0.85, 0.6, GUN, O); // Diagonal A-pillar braces raking down to the nose. box(objectApi, "brace-l", -0.34, 0.34, -0.5, -0.28, 0.82, -0.05, GUN, O); box(objectApi, "brace-r", 0.28, 0.34, -0.5, 0.34, 0.82, -0.05, GUN, O); // Roof light bar: a dark housing studded with glowing lamp pods. box(objectApi, "lightbar", -0.34, 0.83, -0.18, 0.34, 0.93, -0.06, DARK, O); for (let i = 0; i < 4; i++) { objectApi.spawn("lamp-" + i, { parent: shellId, properties: { feetPosition: { x: -0.24 + i * 0.16, y: 0.87, z: -0.2 }, primitive: { kind: "cylinder", radius: 0.045, height: 0.04 }, rotation: { pitch: 90 }, material: HEAD }, }); } } else if (style === "f1") { // Low and mean: headrest fairing, the airbox intake snorkel rising behind the // driver, and the modern halo arcing over the cockpit. box(objectApi, "headrest", -0.17, 0.42, 0.42, 0.17, 0.62, 0.62, DARK, O); // Airbox: tall triangular intake above/behind the head. box(objectApi, "airbox", -0.12, 0.6, 0.5, 0.12, 0.86, 0.66, RED, O); box(objectApi, "airbox-mouth", -0.09, 0.68, 0.46, 0.09, 0.82, 0.52, DARK, O); // Halo: central pylon up front + a ring hoop arcing over the cockpit. box(objectApi, "halo-pylon", -0.04, 0.34, -0.42, 0.04, 0.62, -0.34, GUN, O); objectApi.spawn("halo", { parent: shellId, properties: { feetPosition: { x: 0, y: 0.58, z: 0.05 }, primitive: { kind: "torus", radius: 0.34, tube: 0.035 }, rotation: { pitch: 90 }, material: GUN, }, }); } else { // Classic single roll hoop (red + hot-rod). objectApi.spawn("hoop", { parent: shellId, properties: { feetPosition: { x: 0, y: 0.5, z: 0.6 }, primitive: { kind: "torus", radius: 0.3, tube: 0.04, arc: Math.PI }, rotation: { roll: 0 }, material: CHRM, }, }); } // Rear engine block + bumper box(objectApi, "engine", -0.32, 0.12, 0.7, 0.32, 0.42, 1.0, DARK, O); box(objectApi, "rbar", -0.5, 0.14, 1.02, 0.5, 0.2, 1.08, CHRM, O); // Rear treatment varies per machine. if (style === "f1") { // Two-element rear wing stacked tall, big endplates, a low beam wing under it, // and a glowing rain light in the center. box(objectApi, "wing", -0.5, 0.82, 0.96, 0.5, 0.88, 1.16, RED, O); box(objectApi, "wing-flap", -0.5, 0.72, 1.04, 0.5, 0.78, 1.16, DARK, O); box(objectApi, "beamwing", -0.42, 0.5, 1.02, 0.42, 0.55, 1.14, DARK, O); // Tall endplates closing off the wing tips. box(objectApi, "ep-l", -0.52, 0.46, 0.98, -0.46, 0.9, 1.18, CHRM, O); box(objectApi, "ep-r", 0.46, 0.46, 0.98, 0.52, 0.9, 1.18, CHRM, O); // Center swan-neck supports. box(objectApi, "ws-l", -0.14, 0.5, 1.04, -0.08, 0.84, 1.12, GUN, O); box(objectApi, "ws-r", 0.08, 0.5, 1.04, 0.14, 0.84, 1.12, GUN, O); // Glowing rain light. box(objectApi, "rainlight", -0.05, 0.52, 1.13, 0.05, 0.6, 1.17, GLOW, O); } else if (style === "hotrod") { // No wing — twin chrome exhaust stacks rake up out of the back. objectApi.spawn("exh-l", { parent: shellId, properties: { feetPosition: { x: -0.26, y: 0.4, z: 0.92 }, primitive: { kind: "cylinder", radius: 0.05, height: 0.55 }, rotation: { pitch: 22 }, material: CHRM }, }); objectApi.spawn("exh-r", { parent: shellId, properties: { feetPosition: { x: 0.26, y: 0.4, z: 0.92 }, primitive: { kind: "cylinder", radius: 0.05, height: 0.55 }, rotation: { pitch: 22 }, material: CHRM }, }); } else if (style === "buggy") { // Mounted spare wheel on the tail, a side snorkel intake, and a strapped // jerry can — no wing. objectApi.spawn("spare", { parent: shellId, properties: { feetPosition: { x: 0, y: 0.32, z: 1.06 }, primitive: { kind: "cylinder", radius: 0.24, height: 0.13 }, rotation: { pitch: 90 }, material: { color: "oklch(0.16 0.01 0)", roughness: 0.95 } }, }); objectApi.spawn("spare-hub", { parent: shellId, properties: { feetPosition: { x: 0, y: 0.32, z: 1.13 }, primitive: { kind: "cylinder", radius: 0.1, height: 0.04 }, rotation: { pitch: 90 }, material: GUN }, }); // Snorkel running up the right A-pillar. box(objectApi, "snorkel", 0.46, 0.34, -0.2, 0.54, 0.86, -0.08, GUN, O); box(objectApi, "snorkel-head", 0.44, 0.82, -0.26, 0.56, 0.92, -0.06, DARK, O); // Jerry can strapped behind the cage. box(objectApi, "jerry", -0.36, 0.44, 0.78, -0.18, 0.72, 0.98, YEL, O); } else { // Classic low rear wing. box(objectApi, "wing", -0.42, 0.5, 0.95, 0.42, 0.56, 1.08, RED, O); box(objectApi, "ws-l", -0.4, 0.42, 0.96, -0.34, 0.5, 1.06, DARK, O); box(objectApi, "ws-r", 0.34, 0.42, 0.96, 0.4, 0.5, 1.06, DARK, O); } // Number panels box(objectApi, "num-l", -0.61, 0.16, 0.05, -0.595, 0.3, 0.35, YEL, O); box(objectApi, "num-r", 0.595, 0.16, 0.05, 0.61, 0.3, 0.35, YEL, O); // Wheels for (let i = 0; i < WHEELS.length; i++) { const w = WHEELS[i]; const wheelRot = { roll: 90 }; const wheelPos = wheelFeetFromCenter({ x: w.x, y: w.y, z: w.z }, wheelRot); objectApi.spawn("wheel-" + i, { parent: shellId, properties: { feetPosition: wheelPos, primitive: { kind: "cylinder", radius: WHEEL_R, height: WHEEL_W }, rotation: wheelRot, material: { color: "oklch(0.16 0.01 0)", roughness: 0.95 }, }, }); objectApi.spawn("hub-" + i, { parent: shellId, properties: { feetPosition: wheelFeetFromCenter({ x: w.x, y: w.y, z: w.z }, wheelRot), primitive: { kind: "cylinder", radius: WHEEL_R * 0.45, height: WHEEL_W + 0.02 }, rotation: wheelRot, material: CHRM, }, }); } // Engine voice — a spatial synth motor that revs with this kart's throttle and // screams on nitro. Timbre branches by body style inside engine.vibe.js. Silent // until someone takes the seat (driven flag), so a parked grid stays quiet. objectApi.setProperty("audio", { kind: "vibe", script: "scripts/engine.vibe.js", spatial: false, bus: "SFX", gain: 0.63, params: { style, rpm: 0, throttle: 0, nitro: 0, driven: 0 }, }); } function mountPlayer(player, objectApi) { const prev = objectApi.getObjectProperty(player.id, "physics"); objectApi.patchObjectState(player.id, { mountPrevPhysics: prev, velocity: { x: 0, y: 0, z: 0 } }); objectApi.setObjectProperty(player.id, "physics", null); objectApi.setObjectProperty(player.id, "parent", objectApi.id); objectApi.setObjectProperty(player.id, "feetPosition", SEAT_LOCAL_POS); objectApi.setObjectProperty(player.id, "visible", false); } function dismountPlayer(player, objectApi) { const pos = objectApi.getProperty("feetPosition"); const yaw = objectApi.getProperty("yaw") ?? 0; const { directionFromYawPitch } = require("builtin/vec3"); const side = directionFromYawPitch(yaw - 90, 0); const st = objectApi.getObjectState(player.id) || {}; let exitX = pos.x + side.x * 2.5; let exitZ = pos.z + side.z * 2.5; let exitY = pos.y + 0.5; // Drop the exit point onto solid ground so we never spill the player into the // terrain. Raycast down from above the chosen spot and stand on whatever we hit. const ground = objectApi.raycast({ x: exitX, y: pos.y + 4, z: exitZ }, { x: 0, y: -1, z: 0 }, { maxDistance: 12 }); if (ground && ground.point) exitY = ground.point.y + 0.1; objectApi.setObjectProperty(player.id, "parent", false); objectApi.setObjectProperty(player.id, "feetPosition", { x: exitX, y: exitY, z: exitZ }); // Always hand back a real character body. Restoring null here left players // colliderless — they'd sink straight through the ground on every dismount. const restorePhys = (st.mountPrevPhysics && st.mountPrevPhysics.body) ? st.mountPrevPhysics : { body: "character" }; objectApi.setObjectProperty(player.id, "physics", restorePhys); objectApi.setObjectProperty(player.id, "visible", true); objectApi.patchObjectState(player.id, { velocity: { x: 0, y: 0, z: 0 }, mountPrevPhysics: null }); } export function onInteract(other, objectApi) { if (!other.tags.includes("player")) return; const ownerId = objectApi.id + "-owner"; const ctrl = objectApi.getController(); // A parked kart is always held by its invisible parking owner (that's what keeps // it server-authoritative so it never desyncs). A *player* controller means the // seat is taken — block that. The parking owner just steps aside. if (ctrl && ctrl !== ownerId) return; // Door's closed while a match is live — you can only join during the lobby / // countdown window. Anyone arriving mid-run waits for the next round. const prize = (objectApi.query({ tags: ["prize"] }) || [])[0]; if (prize && (prize.state || {}).phase === "live") { objectApi.toast("Match in progress — wait for the next round", { duration: 2.5 }); return; } const rotation = objectApi.getProperty("rotation"); if (rotation && typeof rotation === "object") { const up = rotateVec3ByQuat(0, 1, 0, rotation); if (up.y < 0.35) { const pos = objectApi.getProperty("feetPosition"); const yaw = objectApi.getProperty("yaw") ?? 0; objectApi.setProperty("rotation", { yaw }); objectApi.setProperty("feetPosition", { x: pos.x, y: pos.y + 1.0, z: pos.z }); objectApi.setVelocity(0, 0, 0); objectApi.patchState({ gas: 0, steer: 0, brake: 0, drift: 0, nitro: 0, currentSteering: 0 }); for (let i = 0; i < 4; i++) { objectApi.setWheelEngineForce(i, 0); objectApi.setWheelBrake(i, 0); objectApi.setWheelSteering(i, 0); } return; } } // Take the keys off the parking owner and hand them to the player — same tick, // so the kart is never committed as ownerless for a late joiner to misread. if (ctrl === ownerId) objectApi.release(); objectApi.transferControl(other.id, objectApi.id); } export function onControlBegin(player, objectApi) { // The invisible parking owner also "takes control" of an idle kart. Accept that // silently — only a real player gets seated and given a camera. if (!player || !player.tags || !player.tags.includes("player")) return true; mountPlayer(player, objectApi); // Control link is wired AFTER this hook returns — so we don't attach the chase // camera here (it would race the engine's control setup). update() does it next // tick, once control is live. _camSet:false tells it to fire. objectApi.patchState({ driverId: player.id, _camSet: false, ctrlT: 0.0001 }); return true; } export function onControlEnd(player, objectApi) { // Parking owner stepping aside (handoff to a player) — nothing was mounted, so // skip the whole dismount/park teardown. if (!player || !player.tags || !player.tags.includes("player")) return; const s = objectApi.getState(); objectApi.clearCamera(); // Cut the engine voice — parked karts go quiet (update early-returns before it // can zero these, so we do it here on the way out). objectApi.patchVibeParams(objectApi.id, { rpm: 0, throttle: 0, nitro: 0, driven: 0 }); objectApi.patchState({ gas: 0, steer: 0, brake: 0, drift: 0, nitro: 0, currentSteering: 0, engRpm: 0, driverId: null, _camSet: false }); dismountPlayer(player, objectApi); for (let i = 0; i < 4; i++) { objectApi.setWheelEngineForce(i, 0); objectApi.setWheelBrake(i, 0); objectApi.setWheelSteering(i, 0); } // The kart is permanent — it never gets destroyed. Park it back on its home grid // slot, upright, mended and full, so the lobby always shows a fresh row of karts // ready for the next racer. A still kart on the grid can't drift between screens. parkHome(objectApi, s); } // Snap a kart back to its starting-grid slot, dead still, fully mended. function parkHome(objectApi, s) { if (s.homeX == null) return; objectApi.setVelocity(0, 0, 0); objectApi.setProperty("feetPosition", { x: s.homeX, y: { terrain: 0.4 }, z: s.homeZ }); objectApi.setProperty("rotation", { yaw: s.homeYaw ?? 0 }); objectApi.patchState({ hp: 100, partsOff: [], wreckSpin: null, koExploding: false, slowT: 0, padBoostT: 0, heldWeapon: null }); } // --- Track centerline (closed loop) for F-recovery and off-track rescue --- const TRACK_PTS = [ { x: 70, z: 0 }, { x: 62, z: 38 }, { x: 38, z: 58 }, { x: 0, z: 62 }, { x: -38, z: 56 }, { x: -64, z: 34 }, { x: -72, z: 0 }, { x: -60, z: -36 }, { x: -30, z: -54 }, { x: 10, z: -60 }, { x: 48, z: -46 }, { x: 66, z: -26 }, ]; const TRACK_HALF_WIDTH = 7; // Closest point on the closed centerline + the forward racing yaw there. function nearestOnTrack(x, z) { let best = null; const n = TRACK_PTS.length; for (let i = 0; i < n; i++) { const a = TRACK_PTS[i], b = TRACK_PTS[(i + 1) % n]; const dx = b.x - a.x, dz = b.z - a.z; const len2 = dx * dx + dz * dz || 1; let t = ((x - a.x) * dx + (z - a.z) * dz) / len2; t = Math.max(0, Math.min(1, t)); const px = a.x + dx * t, pz = a.z + dz * t; const d2 = (x - px) * (x - px) + (z - pz) * (z - pz); if (!best || d2 < best.d2) { const tl = Math.hypot(dx, dz) || 1; best = { d2, x: px, z: pz, tx: dx / tl, tz: dz / tl }; } } best.yaw = Math.atan2(-best.tx, -best.tz) * RAD2DEG; // forward is -Z at yaw 0 best.dist = Math.sqrt(best.d2); return best; } // Is (x,z) inside the closed loop? The whole infield is a playable arena // (power-ups live in there), so anything inside the loop is in-bounds. function insideTrackLoop(x, z) { let inside = false; const n = TRACK_PTS.length; for (let i = 0, j = n - 1; i < n; j = i++) { const a = TRACK_PTS[i], b = TRACK_PTS[j]; if ((a.z > z) !== (b.z > z) && x < ((b.x - a.x) * (z - a.z)) / (b.z - a.z) + a.x) { inside = !inside; } } return inside; } // Snap the kart back onto the track, upright, facing the racing direction. // Repositions only — health and battle damage carry over (death flow comes later). function recoverToTrack(objectApi) { const pos = objectApi.getProperty("feetPosition"); const near = nearestOnTrack(pos.x, pos.z); objectApi.setProperty("rotation", { yaw: near.yaw }); objectApi.setProperty("feetPosition", { x: near.x, z: near.z, y: { terrain: 0.35 } }); objectApi.setVelocity(0, 0, 0); // Hold flat for a beat (recoverT) so residual spin bleeds off instead of tipping it. objectApi.patchState({ gas: 0, steer: 0, brake: 0, drift: 0, nitro: 0, currentSteering: 0, recoverT: 0.9, recoverYaw: near.yaw, prevSpeed: 0, wreckT: 0 }); for (let i = 0; i < 4; i++) { objectApi.setWheelEngineForce(i, 0); objectApi.setWheelBrake(i, 0); objectApi.setWheelSteering(i, 0); } } // KNOCKOUT — health hit zero by ANY cause (a punch, a ram, or grinding yourself // into a wall). Explosion in place, a point banked for the killer if there is one // (byId), then exactly one second later an F-style respawn: snapped back onto the // track, upright, full health, parts mended. Idempotent via koExploding so it can't // double-fire while the kart is waiting to come back. function triggerKO(objectApi, byId) { const s = objectApi.getState() || {}; if (s.koExploding) return; const feet = objectApi.getProperty("feetPosition") || { x: 0, y: 0, z: 0 }; objectApi.setVelocity(0, 0, 0); objectApi.playSound("/cdn/moodboard-supertux-sunny-circuit/sfx-kart-explode.mp3", { position: feet, volume: 1.1, audience: { kind: "place" } }); objectApi.particleBurst({ x: feet.x, y: feet.y + 0.6, z: feet.z }, "explosion", { scale: 2.6, audience: { kind: "place" } }); objectApi.particleBurst({ x: feet.x, y: feet.y + 0.5, z: feet.z }, "fire", { scale: 1.9, audience: { kind: "place" } }); if (s.driverId) objectApi.screenShake(0.85, 0.45, { audience: { kind: "player", id: s.driverId } }); const patch = { hp: 0, wreckT: 0, recoverT: 0, prevSpeed: 0, pendingHit: null, hitFlash: 0.6, koExploding: true }; if (byId) { patch.koCount = (s.koCount || 0) + 1; patch.koBy = byId; } objectApi.patchState(patch); objectApi.runInSeconds(1, function () { recoverToTrack(objectApi); const cs = objectApi.getState() || {}; if (cs.shellId) { for (const part of DETACHABLE) objectApi.setObjectProperty(cs.shellId + "/" + part.suffix, "visible", true); } objectApi.patchState({ hp: 100, partsOff: [], koExploding: false }); }); } // Submit a stunt to the global board. Returns true if it beat the standing record. function submitRecord(objectApi, kind, value, driverId) { const boards = objectApi.query({ tags: ["stunt-board"] }); if (!boards.length) return false; const id = boards[0].id; const bs = objectApi.getObjectState(id) || {}; const records = {}; const old = bs.records || {}; for (const k in old) records[k] = { ...old[k] }; const cur = records[kind] || { value: 0, holder: "" }; if (value <= (cur.value ?? 0)) return false; const name = (driverId && objectApi.getProfile(driverId)?.displayName) || "Racer"; records[kind] = { value: Math.round(value * 10) / 10, holder: name }; objectApi.patchObjectState(id, { records }); return true; } // Throw whatever weapon the kart is holding. One-shot: it's spent after firing. function fireWeapon(objectApi) { const s = objectApi.getState(); if (!s.driverId) return; const w = s.heldWeapon; if (!w) { objectApi.toast("No item — drive through a box!", { duration: 1.2 }); return; } if (w === "punch") firePunch(objectApi, s); else if (w === "jump") fireJump(objectApi, s); else if (w === "shield") fireShield(objectApi, s); else if (w === "banana") fireBanana(objectApi, s); } // HONK. Pure comedy — no gameplay effect, just a fat horn blast, a puff of // exhaust out the tailpipe, and a tiny chassis bounce so the whole kart leans // into it. Everyone nearby hears it. function fireHorn(objectApi) { const s = objectApi.getState(); if (!s.driverId) return; const feet = objectApi.getProperty("feetPosition") || { x: 0, y: 0, z: 0 }; objectApi.playSound("/cdn/moodboard-supertux-sunny-circuit/sfx-kart-horn.mp3", { position: feet, volume: 0.9, audience: { kind: "place" } }); // exhaust pop out the back let fwdX = 0, fwdZ = 1; const rot = objectApi.getProperty("rotation"); if (rot && rot.w !== undefined) { const f = rotateVec3ByQuat(0, 0, -1, rot); fwdX = f.x; fwdZ = f.z; } objectApi.particleBurst({ x: feet.x - fwdX * 1.4, y: feet.y + 0.35, z: feet.z - fwdZ * 1.4 }, "smoke", { scale: 0.6, audience: { kind: "place" } }); } const SHIELD_DUR = 5; // seconds the guard holds const SHIELD_RADIUS = 1.0; // bubble radius — snug around the kart const SHIELD_CENTER_Y = 0.55; // bubble center height above the kart base // Bubble guard, Mario-Kart-style: a glowing translucent dome wraps the whole // kart. The sphere is parented DIRECTLY to the kart body, so it rides perfectly // glued on — no spin, no drift, it just follows you. While it's up, any punch // that lands reflects back at the puncher (connectPunch). function fireShield(objectApi, s) { const feet = objectApi.getProperty("feetPosition") || { x: 0, y: 0, z: 0 }; const parentId = s.shellId || objectApi.id; const bubbleId = objectApi.spawn("shield-bubble", { parent: parentId, tags: ["fx"], properties: { primitive: { kind: "sphere", radius: SHIELD_RADIUS, widthSegments: 32, heightSegments: 24 }, feetPosition: { x: 0, y: SHIELD_CENTER_Y - SHIELD_RADIUS, z: 0 }, material: { texture: "/cdn/moodboard-supertux-sunny-circuit/texture-shield-bubble.png", color: "oklch(0.78 0.2 295)", emissive: "oklch(0.72 0.26 305)", emissiveIntensity: 0.7, opacity: 0.32, transparent: true, side: "double", depthWrite: false, roughness: 0.15, metalness: 0.0, }, }, }); objectApi.playSound("/cdn/moodboard-supertux-sunny-circuit/sfx-shield-shimmer.mp3", { position: feet, volume: 0.8, audience: { kind: "place" } }); objectApi.particleBurst({ x: feet.x, y: feet.y + 0.6, z: feet.z }, "magic", { scale: 0.9, color: "oklch(0.72 0.28 305)", audience: { kind: "place" } }); objectApi.patchState({ heldWeapon: null, shieldT: SHIELD_DUR, shieldPivot: null, shieldOrbs: [bubbleId], shieldAngle: 0 }); } // Panic hop: a hard vertical pop — leap an incoming kart or a thrown punch. // Keeps your horizontal momentum (you don't get shoved forward), just adds lift. function fireJump(objectApi, s) { const vel = objectApi.getVelocity() || { x: 0, y: 0, z: 0 }; objectApi.setVelocity(vel.x, 12.5, vel.z); const feet = objectApi.getProperty("feetPosition") || { x: 0, y: 0, z: 0 }; objectApi.playSound("/cdn/moodboard-supertux-sunny-circuit/sfx-spring-boing.mp3", { position: feet, volume: 0.85, audience: { kind: "place" } }); objectApi.particleBurst({ x: feet.x, y: feet.y + 0.1, z: feet.z }, "smoke", { scale: 0.8, color: "oklch(0.9 0.03 90)", audience: { kind: "place" } }); if (s.driverId) objectApi.screenShake(0.1, 0.14, { audience: { kind: "player", id: s.driverId } }); objectApi.patchState({ heldWeapon: null }); } // Banana peel: drop a slip hazard on the track just behind the kart. Any racer who // drives over it (except behind a shield) gets bogged down — momentum scrubbed and // top speed throttled for ~1.4s. The peel arms after a short beat so you can't slip // on your own drop, and self-despawns so the track never piles up with old peels. function fireBanana(objectApi, s) { const rot = objectApi.getProperty("rotation"); let fwdX, fwdZ; if (rot && rot.w !== undefined) { const f = rotateVec3ByQuat(0, 0, -1, rot); const fl = Math.hypot(f.x, f.z) || 1; fwdX = f.x / fl; fwdZ = f.z / fl; } else { const rad = ((rot && rot.yaw !== undefined) ? rot.yaw : 0) * DEG2RAD; fwdX = -Math.sin(rad); fwdZ = -Math.cos(rad); } const feet = objectApi.getProperty("feetPosition") || { x: 0, y: 0, z: 0 }; const dropX = feet.x - fwdX * 2.4, dropZ = feet.z - fwdZ * 2.4; objectApi.spawn("banana-" + Math.floor(objectApi.random() * 99999), { tags: ["hazard", "banana"], behavior: ["scripts/banana-peel.js"], state: { dropper: objectApi.id }, properties: { feetPosition: { x: dropX, z: dropZ, y: { terrain: 0.05 } }, model: "/cdn/model-cartoon-yellow-banana-peel-prop-yugyzukl.glb", layout: { maxExtents: { x: 1.44, y: 0.72, z: 1.44 } }, rotation: { yaw: Math.floor(objectApi.random() * 360) }, }, }); objectApi.playSound("/cdn/moodboard-supertux-sunny-circuit/sfx-banana-drop.mp3", { position: feet, volume: 0.6, audience: { kind: "place" } }); objectApi.patchState({ heldWeapon: null }); } // Boxing-glove jab: fist VFX flies off the nose, nearest driven kart in the // forward cone takes a hit and gets launched into a cartwheel. function firePunch(objectApi, s) { const rot = objectApi.getProperty("rotation"); // While driving, the body is physics-controlled and rotation is a full // quaternion (no .yaw). Derive forward from whichever form we got so the // punch fires where the nose actually points, not due north. let fwdX, fwdZ; if (rot && rot.w !== undefined) { const f = rotateVec3ByQuat(0, 0, -1, rot); const fl = Math.hypot(f.x, f.z) || 1; fwdX = f.x / fl; fwdZ = f.z / fl; } else { const rad = ((rot && rot.yaw !== undefined) ? rot.yaw : 0) * DEG2RAD; fwdX = -Math.sin(rad); fwdZ = -Math.cos(rad); } const feet = objectApi.getProperty("feetPosition") || { x: 0, y: 0, z: 0 }; // glove is parented to the kart body so it rides along at any speed — it // punches out the nose in the car's LOCAL frame (forward = -Z), no world drift. if (s.shellId) { objectApi.spawn("glove-" + Math.floor(objectApi.random() * 99999), { tags: ["fx"], parent: s.shellId, behavior: ["scripts/punch-glove.js"], state: { baseY: 0.55, baseZ: -1.4 }, properties: { feetPosition: { x: 0, y: 0.55, z: -1.4 }, primitive: { kind: "ellipsoid", radiusX: 0.538, radiusY: 0.493, radiusZ: 0.658 }, material: { color: "oklch(0.58 0.24 28)", roughness: 0.35, emissive: "oklch(0.5 0.2 28)", emissiveIntensity: 0.35 }, }, }); } objectApi.playSound("/cdn/moodboard-supertux-sunny-circuit/sfx-punch-whoosh.mp3", { position: feet, volume: 0.7, audience: { kind: "place" } }); if (s.driverId) objectApi.screenShake(0.12, 0.12, { audience: { kind: "player", id: s.driverId } }); // The hit lands when the fist reaches full extension (~peak of the thrust), // re-checked against where the nose points RIGHT THEN — so it only connects // if a kart is actually under the glove at the moment of contact. objectApi.runInSeconds(0.13, function () { connectPunch(objectApi); }); objectApi.patchState({ heldWeapon: null }); } // Contact check at the peak of the punch. Recomputes heading + position live so // fast karts still connect where the fist actually is. function connectPunch(objectApi) { const cs = objectApi.getState(); const rot = objectApi.getProperty("rotation"); let fwdX, fwdZ; if (rot && rot.w !== undefined) { const f = rotateVec3ByQuat(0, 0, -1, rot); const fl = Math.hypot(f.x, f.z) || 1; fwdX = f.x / fl; fwdZ = f.z / fl; } else { const rad = ((rot && rot.yaw !== undefined) ? rot.yaw : 0) * DEG2RAD; fwdX = -Math.sin(rad); fwdZ = -Math.cos(rad); } const feet = objectApi.getProperty("feetPosition") || { x: 0, y: 0, z: 0 }; const others = objectApi.query({ tags: ["drivable"], radius: PUNCH_REACH }); let best = null, bestDist = Infinity; for (const o of others) { if (o.id === objectApi.id || !o.feetPosition) continue; const os = objectApi.getObjectState(o.id) || {}; if (!os.driverId && !os.aiDriver) continue; // only KO karts that are occupied (player or bot) const dx = o.feetPosition.x - feet.x, dz = o.feetPosition.z - feet.z; const dist = Math.hypot(dx, dz); if (dist < 0.01 || dist > PUNCH_REACH) continue; if ((dx * fwdX + dz * fwdZ) / dist < PUNCH_CONE) continue; // must be in the cone if (dist < bestDist) { bestDist = dist; best = o; } } if (best) { const bs = objectApi.getObjectState(best.id) || {}; if ((bs.shieldT ?? 0) > 0) { // REFLECTED. The bubble slaps the fist back — the puncher eats their own hit, // launched backward (away from the kart they tried to punch). objectApi.patchObjectState(objectApi.id, { pendingHit: { dmg: PUNCH_DMG, dirX: -fwdX, dirZ: -fwdZ, by: best.id } }); objectApi.patchObjectState(best.id, { shieldFlash: 0.3 }); objectApi.hitstop(0.09); objectApi.playSound("/cdn/moodboard-supertux-sunny-circuit/sfx-shield-clang.mp3", { position: best.feetPosition, volume: 1, audience: { kind: "place" } }); objectApi.particleBurst({ x: best.feetPosition.x, y: best.feetPosition.y + 0.7, z: best.feetPosition.z }, "magic", { scale: 1.1, color: "oklch(0.75 0.28 305)", audience: { kind: "place" } }); return; } objectApi.patchObjectState(best.id, { pendingHit: { dmg: PUNCH_DMG, dirX: fwdX, dirZ: fwdZ, by: objectApi.id } }); objectApi.hitstop(0.06); objectApi.playSound("/cdn/moodboard-supertux-sunny-circuit/sfx-clown-honk-bonk.mp3", { position: best.feetPosition, volume: 0.9, audience: { kind: "place" } }); // little kick on the puncher for the connect if (cs.driverId) objectApi.screenShake(0.18, 0.16, { audience: { kind: "player", id: cs.driverId } }); } } // --- Simple bot brain --- // Chase the nearest human-driven kart, ram-and-punch it. When no human is // driving, idle in place. Writes gas/steer/etc straight into the kart's own // state so the normal driving code below moves it. function aiThink(objectApi, s, dt) { const me = objectApi.getProperty("feetPosition") || { x: 0, y: 0, z: 0 }; const rot = objectApi.getProperty("rotation"); // Self-right: a bot has no F key, so if it tips over (up-vector points sideways // or down) it would lie there forever. Pop it back onto the track flat. let upY = 1; if (rot && rot.w !== undefined) upY = rotateVec3ByQuat(0, 1, 0, rot).y; else if (rot && rot.pitch === undefined && rot.roll === undefined) upY = 1; if (upY < 0.5) { recoverToTrack(objectApi); objectApi.patchState({ aiStuckT: 0 }); return; } let fwdX, fwdZ; if (rot && rot.w !== undefined) { const f = rotateVec3ByQuat(0, 0, -1, rot); const fl = Math.hypot(f.x, f.z) || 1; fwdX = f.x / fl; fwdZ = f.z / fl; } else { const rad = ((rot && rot.yaw !== undefined) ? rot.yaw : 0) * DEG2RAD; fwdX = -Math.sin(rad); fwdZ = -Math.cos(rad); } // Find the nearest human (real driver) to hunt. The broad 300m scan is // staggered/cached, then each cached id's live position is re-read below so the // steering target stays current without a world query from every bot every tick. let aiScanTick = ((s._aiHuntTick ?? staggerOffset(objectApi.id, AI_HUNT_SCAN_TICKS)) + 1) % AI_HUNT_SCAN_TICKS; let aiHuntIds = Array.isArray(s._aiHuntIds) ? s._aiHuntIds : []; if (aiScanTick === 0 || !Array.isArray(s._aiHuntIds)) aiHuntIds = queryDrivableIds(objectApi, 300); let target = null, bestD = Infinity; for (let i = 0; i < aiHuntIds.length; i++) { const o = liveDrivableSnapshot(objectApi, aiHuntIds[i]); if (!o) continue; const os = o.state || {}; if (!os.driverId) continue; // hunt humans only const d = Math.hypot(o.feetPosition.x - me.x, o.feetPosition.z - me.z); if (d < bestD) { bestD = d; target = o; } } let aiPunchCD = Math.max(0, (s.aiPunchCD ?? 0) - dt); if (!target) { // Nobody to chase — coast to a gentle stop. s.gas = 0; s.steer = 0; s.brake = 1; s.drift = 0; s.nitro = 0; objectApi.patchState({ gas: 0, steer: 0, brake: 1, drift: 0, nitro: 0, aiPunchCD, _aiHuntTick: aiScanTick, _aiHuntIds: aiHuntIds }); return; } // Steer toward the target: signed turn from heading error. let dx = target.feetPosition.x - me.x, dz = target.feetPosition.z - me.z; const dl = Math.hypot(dx, dz) || 1; dx /= dl; dz /= dl; const dot = fwdX * dx + fwdZ * dz; // >0 = target ahead const cross = fwdX * dz - fwdZ * dx; // sign = which way to turn // steerInput is later applied as -maxSteer*steer, so flip the sign here. let steer = Math.max(-1, Math.min(1, -cross * 2.2)); if (dot < 0.2) steer = cross > 0 ? -1 : 1; // target off to the side / behind → hard turn // Throttle: floor it toward them, ease off if pointed away so it can pivot. const gas = dot > -0.3 ? 1 : 0.45; s.gas = gas; s.steer = steer; s.brake = 0; s.drift = 0; s.nitro = bestD > 40 ? 1 : 0; // close the gap from far out // Wedged against a wall while flooring it? Speed pinned near zero for a beat // → unstick by snapping back to the racing line. const spd = Math.abs(objectApi.getVehicleSpeed()); let aiStuckT = (spd < 1.5 && gas > 0.5) ? (s.aiStuckT ?? 0) + dt : 0; if (aiStuckT > 2) { recoverToTrack(objectApi); objectApi.patchState({ aiStuckT: 0, aiPunchCD, _aiHuntTick: aiScanTick, _aiHuntIds: aiHuntIds }); return; } // In range and roughly facing them → throw hands. if (aiPunchCD <= 0 && bestD < PUNCH_REACH + 1.5 && dot > 0.55) { firePunch(objectApi, s); aiPunchCD = 1.4; } objectApi.patchState({ gas: s.gas, steer: s.steer, brake: 0, drift: 0, nitro: s.nitro, aiPunchCD, aiStuckT, _aiHuntTick: aiScanTick, _aiHuntIds: aiHuntIds }); } export function onInput(input, objectApi) { if (input.actions.interact) { objectApi.release(); return; } if (input.actions.recover) { recoverToTrack(objectApi); } if (input.actions.fire) { fireWeapon(objectApi); } if (input.actions.horn) { fireHorn(objectApi); } objectApi.patchState({ gas: input.axes.moveZ ?? 0, steer: input.axes.moveX ?? 0, brake: 0, // no dedicated brake — ease off / reverse with S drift: input.actions.drift ? 1 : 0, nitro: input.actions.nitro ? 1 : 0, // turbo on SPACE (and Q), held }); } export function update(dt, objectApi) { const s = objectApi.getState(); // A freshly-spawned runtime kart waiting to be handed to its driver. We do the // control transfer here — a tick after spawn — rather than in onInteract, so // the new entity is fully registered first, and so other players receive it // already wearing its controller (the crux of the sync fix). if (s.awaitDriver && !objectApi.getController()) { objectApi.transferControl(s.awaitDriver, objectApi.id); objectApi.patchState({ awaitDriver: null }); return; } // --- Parking owner --- whenever no human is at the wheel (idle on the grid, or a // bot is driving), keep an invisible owner entity attached as the kart's controller. // An UNOWNED scripted/vehicle body gets simulated independently on every client, and // a late joiner permanently classifies it as locally-predicted and ignores the // server's snaps — that is the 3rd-player desync. An owned kart is always // server-authoritative, so every screen agrees on it. (No-ops if owner is missing.) if (!s.driverId) { const ownerId = objectApi.id + "-owner"; if (objectApi.getController() !== ownerId) objectApi.transferControl(ownerId, objectApi.id); } // A bot kart "holds the wheel" by writing gas/steer into its own state here, // in place, before the driving code below reads them. if (s.aiDriver) aiThink(objectApi, s, dt); // --- Parked hold --- a kart with NOBODY at the wheel (no player, no bot) is a // display piece on the grid, not a loose physics body. Pin it dead-on its home // slot every tick: same spot, same facing, zero velocity, brakes locked. This is // what stops a driverless kart from rolling off, slowly self-rotating, sinking, // or drifting between screens — a still, scripted kart can't desync. if (!s.driverId && !s.aiDriver) { objectApi.setVelocity(0, 0, 0); if (s.homeX != null) { objectApi.setProperty("feetPosition", { x: s.homeX, y: { terrain: 0.4 }, z: s.homeZ }); objectApi.setProperty("rotation", { yaw: s.homeYaw ?? 0 }); } for (let i = 0; i < 4; i++) { objectApi.setWheelEngineForce(i, 0); objectApi.setWheelBrake(i, 200); objectApi.setWheelSteering(i, 0); } return; } // --- Shield bubble lifetime --- // Counts down while up; when it expires, pop the orb. shieldT > 0 is what // connectPunch checks to reflect an incoming punch. if ((s.shieldT ?? 0) > 0) { const left = s.shieldT - dt; const orbs = s.shieldOrbs || []; if (left <= 0) { for (const id of orbs) { try { objectApi.destroy(id); } catch (e) {} } if (s.shieldPivot) { try { objectApi.destroy(s.shieldPivot); } catch (e) {} } const feet = objectApi.getProperty("feetPosition") || { x: 0, y: 0, z: 0 }; objectApi.particleBurst({ x: feet.x, y: feet.y + 0.6, z: feet.z }, "magic", { scale: 0.4, color: "oklch(0.72 0.28 305)", audience: { kind: "place" } }); objectApi.patchState({ shieldT: 0, shieldPivot: null, shieldOrbs: [], shieldAngle: 0 }); } else { // Dome is a static child of the kart — nothing to animate, just tick down. objectApi.patchState({ shieldT: left }); } } const speed = Math.abs(objectApi.getVehicleSpeed()); const gas = s.gas ?? 0; // --- Mount / camera self-heal --- // transferControl runs onControlBegin BEFORE it wires the control link, and the // mount + camera override are runtime-only (a reconcile/rejoin can revert them // while driverId persists). So we own the handoff here, where control is already // live: attach the chase cam once, keep the driver seated, and if the control // link is gone, fully release so nobody is ever stranded with a frozen camera. if (s.driverId) { const controller = objectApi.getController(); if (!controller) { const pid = s.driverId; const pst = objectApi.getObjectState(pid) || {}; objectApi.setObjectProperty(pid, "parent", false); objectApi.setObjectProperty(pid, "visible", true); objectApi.setObjectProperty(pid, "physics", pst.mountPrevPhysics ?? { body: "character", collider: "capsule" }); objectApi.clearCamera({ audience: { kind: "player", id: pid } }); objectApi.patchState({ driverId: null, _camSet: false }); // Driver vanished (disconnect / mid-run release) — the kart is permanent, so // we never destroy it. Just park it back on its home grid slot for the next racer. parkHome(objectApi, s); return; } if (objectApi.getObjectProperty(s.driverId, "parent") !== objectApi.id) { objectApi.setObjectProperty(s.driverId, "parent", objectApi.id); objectApi.setObjectProperty(s.driverId, "physics", null); objectApi.setObjectProperty(s.driverId, "feetPosition", SEAT_LOCAL_POS); objectApi.setObjectProperty(s.driverId, "visible", false); } if (!s._camSet) { objectApi.setCamera( { kind: "custom", state: { headingYaw: 0, followDist: 8, currentDist: 8 }, pointerLock: false, hideLocalPlayer: true, behavior: ["scripts/kart-camera.js"] }, { mode: "replace" } ); objectApi.patchState({ _camSet: true }); } } // --- Took a weapon hit --- a punch (or future shell) from another racer flags // us with pendingHit. Consume it here, launch into a tumble, and let next // frame's wreck handler cartwheel us out. Always launches — getting hit means // you go flying, that's the whole joy of it. if ((s.driverId || s.aiDriver) && s.pendingHit) { const ph = s.pendingHit; const feet = objectApi.getProperty("feetPosition") || { x: 0, y: 0, z: 0 }; // Already mid-explosion from a previous killing blow — ignore further hits so a // kart can't be double-counted while it's waiting to respawn. if (s.koExploding) { objectApi.patchState({ pendingHit: null }); return; } const newHp = Math.max(0, (s.hp ?? 100) - (ph.dmg ?? 50)); const ko = newHp <= 0; // killing blow — health hit zero // --- KNOCKOUT --- explosion + 1s respawn, point to the puncher. (Shared with // wall self-destruct below via triggerKO.) if (ko) { objectApi.damageNumber({ x: feet.x, y: feet.y + 1.6, z: feet.z }, ph.dmg ?? 30, { color: "oklch(0.98 0.02 90)", size: 2.4, crit: true, audience: { kind: "place" } }); triggerKO(objectApi, ph.by || null); return; } // --- Non-fatal hit --- launch into a tumble; press F (or wait) to recover. const M = 68; const launch = 8.5, kick = 4.5, rate = 7, spin = 1.5; // Seed the tumble from the SHARED hit (direction + puncher id + damage), so // the launch is byte-identical on every client and the server. Any random() // here would fly the kart a different way on each screen and never reconcile. const hseed = ((ph.dirX || 0) * 7.13 + (ph.dirZ || 0) * 3.97 + (ph.dmg || 0) * 0.011 + hashStringId(ph.by) * 0.0007) % 1; objectApi.addImpulse((ph.dirX || 0) * M * kick + (seededUnit(hseed, 1) - 0.5) * M * 2, M * launch, (ph.dirZ || 0) * M * kick + (seededUnit(hseed, 2) - 0.5) * M * 2); const ax = seededUnit(hseed, 3) * 2 - 1, ay = (seededUnit(hseed, 4) * 2 - 1) * 0.3, az = seededUnit(hseed, 5) * 2 - 1; const al = Math.hypot(ax, ay, az) || 1; objectApi.playSound("/cdn/moodboard-supertux-sunny-circuit/sfx-kart-bumper-thud.mp3", { position: { x: feet.x, y: feet.y, z: feet.z }, volume: 1, pitch: 0.88, audience: { kind: "place" } }); objectApi.particleBurst({ x: feet.x, y: feet.y + 0.5, z: feet.z }, "explosion", { scale: 0.8, audience: { kind: "place" } }); objectApi.damageNumber({ x: feet.x, y: feet.y + 1.6, z: feet.z }, ph.dmg ?? 30, { color: "oklch(0.98 0.02 90)", size: 2.2, crit: true, audience: { kind: "place" } }); if (s.driverId) objectApi.screenShake(0.5, 0.4, { audience: { kind: "player", id: s.driverId } }); objectApi.patchState({ hp: newHp, wreckT: spin, wreckSpin: { x: (ax / al) * rate, y: (ay / al) * rate, z: (az / al) * rate }, detachCD: 0.6, hitFlash: 0.6, prevSpeed: 0, pendingHit: null }); return; } // --- Bumper contact --- slam another live racer at speed and they get // knocked loose (lighter than a thrown punch, but the same satisfying spin). // Each kart checks for itself, so a head-on shove rocks both of them. let ramCD = Math.max(0, (s.ramCD ?? 0) - dt); if ((s.driverId || s.aiDriver) && speed > RAM_MIN_SPEED && ramCD <= 0 && (s.wreckT ?? 0) <= 0) { const me = objectApi.getProperty("feetPosition") || { x: 0, y: 0, z: 0 }; const vel = objectApi.getVelocity(); let ramScanTick = ((s._ramScanTick ?? staggerOffset(objectApi.id, RAM_SCAN_TICKS)) + 1) % RAM_SCAN_TICKS; let ramIds = Array.isArray(s._ramIds) ? s._ramIds : []; if (ramScanTick === 0 || !Array.isArray(s._ramIds)) ramIds = queryDrivableIds(objectApi, RAM_REACH + RAM_SCAN_PAD); for (let i = 0; i < ramIds.length; i++) { const o = liveDrivableSnapshot(objectApi, ramIds[i]); if (!o) continue; const os = o.state || {}; if (!(os.driverId || os.aiDriver)) continue; // only live karts take a hit if ((os.shieldT ?? 0) > 0) continue; // shields are handled on punch reflect const dx = o.feetPosition.x - me.x, dz = o.feetPosition.z - me.z; const d = Math.hypot(dx, dz) || 1; if (d > RAM_REACH) continue; const closing = (vel.x * dx + vel.z * dz) / d; // are we driving INTO them? if (closing < RAM_CLOSING) continue; const nx = dx / d, nz = dz / d; objectApi.patchObjectState(o.id, { pendingHit: { dmg: RAM_DMG, dirX: nx, dirZ: nz, by: objectApi.id } }); objectApi.addImpulse(-nx * RAM_RECOIL, 90, -nz * RAM_RECOIL); // we bounce back off the slam const feet = objectApi.getProperty("feetPosition") || me; objectApi.playSound("/cdn/moodboard-supertux-sunny-circuit/sfx-kart-bumper-thud.mp3", { position: feet, volume: 0.85, audience: { kind: "place" } }); ramCD = RAM_CD; break; } objectApi.patchState({ _ramScanTick: ramScanTick, _ramIds: ramIds }); } objectApi.patchState({ ramCD }); // Abandoned: no driver AND no bot. Glide the kart home to its grid slot, // mended and idle, ready for the next racer. Snap only when it's actually out // of place so a parked kart sits quietly without per-frame jitter. if (!s.driverId && !s.aiDriver) { const hx = s.homeX, hz = s.homeZ; if (hx !== undefined && hz !== undefined) { const here = objectApi.getProperty("feetPosition") || { x: hx, z: hz }; const displaced = Math.hypot(here.x - hx, here.z - hz) > 1.5; const damaged = (s.partsOff && s.partsOff.length) || (s.wreckT ?? 0) > 0 || (s.hp ?? 100) < 100; if (displaced || damaged) { objectApi.setProperty("feetPosition", { x: hx, z: hz, y: { terrain: 0.8 } }); objectApi.setProperty("rotation", { yaw: s.homeYaw ?? 180 }); if (s.shellId) { for (const part of DETACHABLE) objectApi.setObjectProperty(s.shellId + "/" + part.suffix, "visible", true); } objectApi.patchState({ gas: 0, steer: 0, brake: 0, drift: 0, nitro: 0, currentSteering: 0, wreckT: 0, recoverT: 0, hp: 100, partsOff: [], speed: 0, prevSpeed: 0, }); } // Hold it dead still every frame — physics can't nudge a parked kart off // its slot, even on a hair of slope. Pin the rotation flat too (yaw only, // no roll/pitch) so a kart that gets bumped onto its side stands itself // back up instead of lying there tipped over. objectApi.setProperty("rotation", { yaw: s.homeYaw ?? 180 }); objectApi.setVelocity(0, 0, 0); for (let i = 0; i < 4; i++) { objectApi.setWheelEngineForce(i, 0); objectApi.setWheelBrake(i, 12); objectApi.setWheelSteering(i, 0); } } return; } // Recovery hold: keep the kart flat and still for a short window after F so // residual spin can't tip it onto its nose. Release once the timer runs out. const recoverT = s.recoverT ?? 0; if (recoverT > 0) { objectApi.setProperty("rotation", { yaw: s.recoverYaw ?? 0 }); objectApi.setVelocity(0, 0, 0); for (let i = 0; i < 4; i++) { objectApi.setWheelEngineForce(i, 0); objectApi.setWheelBrake(i, 0); objectApi.setWheelSteering(i, 0); } objectApi.patchState({ recoverT: recoverT - dt, prevSpeed: 0 }); return; } // --- Loop-the-loop lock --- // While locked we own the kart fully: roll it up the approach ramp, around the // open vertical loop, and down the exit ramp, then fling it out still rolling. // Loop axis is X. dir (+1 / -1) is the travel direction the kart entered with. const A = LOOP.gapDeg * Math.PI / 180; const sinA = Math.sin(A); const hA = LOOP.R * (1 - Math.cos(A)); const startF = LOOP.R * sinA; // gap-edge offset from the bottom center const lr = s.loopRide; if (lr) { const dir = lr.dir ?? 1; const t = (lr.t ?? 0) + dt; if (t >= LOOP_DUR) { const ex = (lr.exitSpeed ?? 18); objectApi.setVelocity(dir * ex, 0.5, 0); objectApi.setProperty("rotation", { yaw: lr.yaw }); objectApi.patchState({ loopRide: null, prevSpeed: ex, loopCD: 1.4 }); return; } // One smooth vertical circle: climb the front edge, over the top, down the // back — in and out within the same little footprint at the bottom. const u = t / LOOP_DUR; const phi = A + (Math.PI * 2 - 2 * A) * u; // gapA -> 2*PI - gapA const f = Math.sin(phi) * LOOP.R; const up = LOOP.R * (1 - Math.cos(phi)); const pitch = phi * 180 / Math.PI; objectApi.setProperty("feetPosition", { x: lr.cx + dir * f, y: lr.baseY + up, z: lr.cz }); objectApi.setProperty("rotation", { yaw: lr.yaw, pitch }); objectApi.setVelocity(0, 0, 0); for (let i = 0; i < 4; i++) { objectApi.setWheelEngineForce(i, 0); objectApi.setWheelBrake(i, 0); objectApi.setWheelSteering(i, 0); } objectApi.patchState({ loopRide: { ...lr, t }, prevSpeed: 0 }); return; } // Catch / bonk: any kart entering the loop footprint along the X racing line. { const feet = objectApi.getProperty("feetPosition") || { x: 0, y: 0, z: 0 }; const vel = objectApi.getVelocity() || { x: 0, y: 0, z: 0 }; const lateral = Math.abs(feet.z - LOOP.z); // off the loop's plane const dx = feet.x - LOOP.x; // along the X axis const grounded = (s.airT ?? 0) <= 0.1; const inFootprint = lateral < LOOP.halfW && Math.abs(dx) < startF + 2.5; if ((s.loopCD ?? 0) > 0) { objectApi.patchState({ loopCD: Math.max(0, (s.loopCD ?? 0) - dt) }); } else if (!LOOP.off && inFootprint && grounded && Math.abs(vel.x) > 1.2 && !(s.wreckT > 0)) { const dir = vel.x > 0 ? 1 : -1; // travel direction // Only engage when actually heading into the loop (not just coasting past). if (dir * dx < startF) { if (speed > LOOP_SPEED_GATE) { objectApi.patchState({ loopRide: { t: 0, cx: LOOP.x, cz: LOOP.z, baseY: feet.y, dir, yaw: objectApi.getProperty("yaw") ?? 0, exitSpeed: Math.max(speed, 14) }, }); objectApi.playSound("/cdn/moodboard-supertux-sunny-circuit/sfx-spring-boing.mp3", { position: feet, volume: 0.9, pitch: 1.15, audience: { kind: "place" } }); return; } else { // Too slow to make it — bump back instead of ghosting through. objectApi.setVelocity(-dir * 5, 0.5, vel.z * 0.5); objectApi.playSound("/cdn/moodboard-supertux-sunny-circuit/sfx-kart-bumper-thud.mp3", { position: feet, volume: 0.8, pitch: 1, audience: { kind: "place" } }); objectApi.patchState({ prevSpeed: 0 }); return; } } } } // Crash tumble: a hard hit launches the kart into the air and it cartwheels on // its own momentum — no steering, no downforce, it lands however it lands. // Press F to recover. Strength + spin axis are seeded at the moment of impact. let wreckT = Math.max(0, (s.wreckT ?? 0) - dt); if (wreckT > 0) { for (let i = 0; i < 4; i++) { objectApi.setWheelEngineForce(i, 0); objectApi.setWheelBrake(i, 0); objectApi.setWheelSteering(i, 0); } const rq = objectApi.getProperty("rotation"); const q = rq && rq.w !== undefined ? rq : quatYaw(rq?.yaw ?? 0); const sp = s.wreckSpin || { x: 0, y: 0, z: 8 }; const mag = Math.hypot(sp.x, sp.y, sp.z); if (mag > 1e-4) { const dq = quatFromAxisAngle(sp.x / mag, sp.y / mag, sp.z / mag, mag * dt); objectApi.setProperty("rotation", quatMul(dq, q)); } objectApi.patchState({ wreckT, prevSpeed: 0 }); return; } // Keep the body awake under control input — a resting vehicle body sleeps // and a sleeping body ignores engine force, so it'd never restart from a stop. const hasInput = Math.abs(gas) > 0.05 || Math.abs(s.steer ?? 0) > 0.05 || (s.brake ?? 0) > 0 || (s.drift ?? 0) > 0; if (hasInput && speed < 0.6) objectApi.addImpulse(0, 0.4, 0); // Nitro const usingNitro = (s.nitro ?? 0) > 0 && (s.nitroTank ?? 0) > 0 && gas > 0; let tank = s.nitroTank ?? NITRO_MAX; if (usingNitro) { tank = Math.max(0, tank - dt); objectApi.particleBurst(objectApi.getProperty("feetPosition"), "fire", { scale: 0.25 }); } else { tank = Math.min(NITRO_MAX, tank + NITRO_RECHARGE * dt); } // Per-style handling personality (accel / top / brake / steer / grip). const tune = styleTune(s); // Boost-pad: a short, mild speed-up the track strip grants (set on this kart's // state when it rolls over a pad). On the FRESH contact it fires a little forward // kick + a swoosh (both from the kart, so the driver always feels/hears it), then // lifts drive force + top-speed ceiling ~15% for the remaining padBoostT seconds. const padRaw = s.padBoostT ?? 0; let padT = Math.max(0, padRaw - dt); const padPrev = s._padPrev ?? 0; if (padRaw > 0 && padPrev <= 0) { const prot = objectApi.getProperty("rotation"); let pfX, pfZ; if (prot && prot.w !== undefined) { const f = rotateVec3ByQuat(0, 0, -1, prot); const fl = Math.hypot(f.x, f.z) || 1; pfX = f.x / fl; pfZ = f.z / fl; } else { const rad = ((prot && prot.yaw !== undefined) ? prot.yaw : 0) * DEG2RAD; pfX = -Math.sin(rad); pfZ = -Math.cos(rad); } // Add velocity directly — a vehicle body shrugs off small impulses, but // setVelocity is authoritative, so the needle actually jumps. +5 m/s (~18km/h) // straight down the nose. const vv = objectApi.getVelocity() || { x: 0, y: 0, z: 0 }; objectApi.setVelocity(vv.x + pfX * 4, vv.y, vv.z + pfZ * 4); objectApi.playSound("/cdn/moodboard-supertux-sunny-circuit/sfx-boost.mp3", { volume: 0.85 }); } if (padRaw > 0) objectApi.patchState({ padBoostT: padT, _padPrev: padT }); else if (padPrev !== 0) objectApi.patchState({ _padPrev: 0 }); const padMult = padT > 0 ? PAD_BOOST_MULT : 1; // Banana slip: bogged down while slowT runs. On the fresh edge, scrub momentum so // the peel actually bites; then a throttled top speed + force until it wears off. const slowRaw = s.slowT ?? 0; const slowT2 = Math.max(0, slowRaw - dt); const slowPrev = s._slowPrev ?? 0; if (slowRaw > 0 && slowPrev <= 0) { const vv = objectApi.getVelocity() || { x: 0, y: 0, z: 0 }; objectApi.setVelocity(vv.x * 0.25, vv.y, vv.z * 0.25); } if (slowRaw !== slowT2 || slowPrev !== slowT2) objectApi.patchState({ slowT: slowT2, _slowPrev: slowT2 }); const slowMult = slowRaw > 0 ? BANANA_SLOW_MULT : 1; // Drive force with soft top-speed taper const speedFrac = Math.min(1, speed / (TOP_SPEED * tune.top * padMult * slowMult)); const taper = gas > 0 ? 1 - speedFrac * speedFrac : 1; let force; if (gas > 0) force = -gas * DRIVE_FORCE * tune.accel * taper * (usingNitro ? NITRO_MULT : 1) * padMult * slowMult; else force = -gas * REVERSE_FORCE; // Drive the engine voice: revs chase max(speed, throttle blip) so it growls on // launch and settles with speed. Smoothed so the pitch ramps, not snaps. const revTarget = Math.min(1, Math.max(speedFrac, Math.abs(gas) * 0.55) + (usingNitro ? 0.15 : 0)); const engRpm = (s.engRpm ?? 0) + (revTarget - (s.engRpm ?? 0)) * Math.min(1, dt * 6); s.engRpm = engRpm; const engineParamTick = ((s._engineParamTick ?? staggerOffset(objectApi.id, ENGINE_PARAM_TICKS)) + 1) % ENGINE_PARAM_TICKS; if (engineParamTick === 0) { objectApi.patchVibeParams(objectApi.id, { rpm: engRpm, throttle: Math.abs(gas), nitro: usingNitro ? 1 : 0, driven: (s.driverId || s.aiDriver) ? 1 : 0, }); } const driftInput = (s.drift ?? 0) > 0; // Keep power feeding the rear through a drift so speed holds — coasting at // zero throttle is what used to scrub all your momentum. const driftThrottle = driftInput ? force * DRIFT_THROTTLE : force; objectApi.setWheelEngineForce(2, driftThrottle); objectApi.setWheelEngineForce(3, driftThrottle); // Downforce: plant at speed, and yank the kart back down when airborne let groundedWheels = 0; for (let i = 0; i < 4; i++) { const w = objectApi.getWheelState(i); if (w && w.suspensionLength < SUSP_REST - 0.01) groundedWheels++; } // Landing grace: while airborne (and for a beat after touchdown) the planar-speed // dip from a hard landing must NOT read as a collision. Refresh in the air, bleed // off once grounded, so only a genuine ground impact can hurt the kart. let landGraceT = Math.max(0, (s.landGraceT ?? 0) - dt); if (groundedWheels === 0) landGraceT = 0.5; // --- Buried-kart guard --- a fast, steep landing off a big ramp can punch the // collider clean through the flat basin floor (y≈0) and wedge it underground with // nothing to shove it back out. If the kart's feet drop below the floor anywhere // inside the paved basin, lift it back to the surface and kill the downward // velocity so it can never stay stuck in the ground. { const fp = objectApi.getProperty("feetPosition"); if (fp && Math.hypot(fp.x, fp.z) < 82 && fp.y < -0.3) { objectApi.setProperty("feetPosition", { x: fp.x, z: fp.z, y: { terrain: 0.45 } }); const v = objectApi.getVelocity() || { x: 0, y: 0, z: 0 }; objectApi.setVelocity(v.x, Math.max(0, v.y), v.z); } } // How far below us is solid ground? A descending kart about to touch down scrubs // planar speed as its collider kisses the surface — that must NOT read as a wall // hit. Only count an air collision when we're genuinely high off the deck. let groundDist = 99; if (groundedWheels === 0) { const fp = objectApi.getProperty("feetPosition"); if (fp) { const hit = objectApi.raycast({ x: fp.x, y: fp.y + 0.3, z: fp.z }, { x: 0, y: -1, z: 0 }, { maxDistance: 8, ignoreIds: [objectApi.id] }); if (hit && hit.point) groundDist = (fp.y + 0.3) - hit.point.y; } } // Off-track rescue: if it lands well outside the road surface, snap it back on. if ((s.driverId || s.aiDriver) && groundedWheels > 0) { const here = objectApi.getProperty("feetPosition"); // In-bounds = on the ribbon OR anywhere inside the loop (the power-up arena). // Only rescue when you're truly outside the outer fence. if (!insideTrackLoop(here.x, here.z)) { const nd = nearestOnTrack(here.x, here.z); if (nd.dist > TRACK_HALF_WIDTH + 6) { recoverToTrack(objectApi); return; } } } const mass = 68; let downImpulse = mass * speed * DOWNFORCE_SPEED * 0.02 * dt; if (groundedWheels === 0) downImpulse += mass * DOWNFORCE_AIR * dt; if ((s.drift ?? 0) > 0 && groundedWheels > 0) downImpulse += mass * DRIFT_DOWNFORCE * dt; if (downImpulse > 0) objectApi.addImpulse(0, -downImpulse, 0); // --- Air control: while airborne, give the player real say over how the kart // lands. Steer swings the nose around, gas tucks it nose-down (back pulls it // up), and a gentle auto-level drifts the kart back toward flat so a jump can // be stuck on its wheels. On the ground this does nothing — flips still stick, // press F to recover. Only wakes after a real beat of air, so lifting the // inside wheels in a hard corner never reads as a jump. --- const airT = groundedWheels === 0 ? (s.airT ?? 0) + dt : 0; objectApi.patchState({ airT }); // Landing skid: just touched down from a real jump? Bleed grip for a beat so the // kart rolls OUT of the landing carrying its momentum instead of biting the // ground and dead-stopping. This is what makes a big jump feel fluid, not sticky. let landSkidT = Math.max(0, (s.landSkidT ?? 0) - dt); if (groundedWheels > 0 && (s.airT ?? 0) > 0.35) landSkidT = 0.4; if (airT >= AIR_ENGAGE && wreckT <= 0) { const rq = objectApi.getProperty("rotation"); let nq = rq && rq.w !== undefined ? rq : quatYaw(rq?.yaw ?? 0); const yawIn = -(s.steer ?? 0); const pitchIn = gas; if (Math.abs(yawIn) > 0.05) { nq = quatMul(quatFromAxisAngle(0, 1, 0, yawIn * AIR_YAW_RATE * dt), nq); } if (Math.abs(pitchIn) > 0.05) { const right = rotateVec3ByQuat(1, 0, 0, nq); nq = quatMul(quatFromAxisAngle(right.x, right.y, right.z, pitchIn * AIR_PITCH_RATE * dt), nq); } // Passive self-righting: nudge the kart's up-vector toward world-up. const up = rotateVec3ByQuat(0, 1, 0, nq); const tilt = Math.acos(Math.max(-1, Math.min(1, up.y))); if (tilt > 0.02) { let ax = -up.z, az = up.x; // cross(up, worldUp) const al = Math.hypot(ax, az); if (al > 1e-4) { ax /= al; az /= al; const correct = Math.min(tilt, AIR_LEVEL_RATE * dt); nq = quatMul(quatFromAxisAngle(ax, 0, az, correct), nq); } } objectApi.setProperty("rotation", nq); } // --- Stunt tracking: longest jump + longest wheelie, chasing the global board --- { const pos = objectApi.getProperty("feetPosition"); // Split front/rear ground contact so we can tell a wheelie from a jump. let frontDown = 0, rearDown = 0; for (let i = 0; i < 4; i++) { const w = objectApi.getWheelState(i); const down = w && w.suspensionLength < SUSP_REST - 0.01; if (i < 2) { if (down) frontDown++; } else { if (down) rearDown++; } } // Jump: airborne arc from takeoff to landing. let inJump = s.inJump ?? false; let jStartX = s.jStartX ?? 0, jStartZ = s.jStartZ ?? 0, jStartY = s.jStartY ?? 0; let jRise = s.jRise ?? 0; let liveJump = s.liveJump ?? 0; let stuntFlash = Math.max(0, (s.stuntFlash ?? 0) - dt); let stuntText = s.stuntText ?? ""; if (groundedWheels === 0 && !inJump && speed > 6) { inJump = true; jStartX = pos.x; jStartZ = pos.z; jStartY = pos.y; jRise = 0; liveJump = 0; } if (inJump) { liveJump = Math.hypot(pos.x - jStartX, pos.z - jStartZ); jRise = Math.max(jRise, pos.y - jStartY); if (groundedWheels > 0) { inJump = false; if (liveJump >= MIN_JUMP_DIST && jRise >= MIN_JUMP_RISE) { const beat = submitRecord(objectApi, "jump", liveJump, s.driverId); if (beat) { stuntFlash = 3; stuntText = "NEW LONGEST JUMP " + liveJump.toFixed(1) + "m"; } } liveJump = 0; } } // Wheelie: rear wheels down, front wheels lifted, rolling forward — not a jump. let wheelieT = s.wheelieT ?? 0; const doingWheelie = !inJump && rearDown >= 1 && frontDown === 0 && speed > 3; if (doingWheelie) { wheelieT += dt; } else { if (wheelieT >= MIN_WHEELIE_T) { const beat = submitRecord(objectApi, "wheelie", wheelieT, s.driverId); if (beat) { stuntFlash = 3; stuntText = "NEW LONGEST WHEELIE " + wheelieT.toFixed(1) + "s"; } } wheelieT = 0; } objectApi.patchState({ inJump, jStartX, jStartZ, jStartY, jRise, liveJump: inJump ? liveJump : 0, wheelieT, liveWheelie: doingWheelie ? wheelieT : 0, stuntFlash, stuntText, }); } // Slip angle for drift detection const steerInput = s.steer ?? 0; const steerAbs = Math.abs(steerInput); const vel = objectApi.getVelocity(); const velMag = Math.hypot(vel.x, vel.z); const rot = objectApi.getProperty("rotation"); const headingRad = (rot?.yaw ?? 0) * DEG2RAD; const fwdX = -Math.sin(headingRad), fwdZ = -Math.cos(headingRad); let slipAngle = 0; if (velMag > 2) { const cross = fwdX * (vel.z / velMag) - fwdZ * (vel.x / velMag); slipAngle = Math.asin(Math.max(-1, Math.min(1, cross))); } const slipDeg = Math.abs(slipAngle) * RAD2DEG; const isSliding = slipDeg > 8; // No auto-righting — the kart pitches and rolls totally free. Flip it, wreck it, // land it however. Press F to recover. // --- Damage --- parts shed ONLY from weapon hits (the pendingHit block above), // never from driving. Bumping a guardrail used to fabricate a crash out of a // speed dip and launch the kart into a random tumble — that fired on phantom // dips and hard corners ("hit something invisible, spun around") and killed // every landing. Gone. A wall is just a wall now: physics bounces you off it // and you keep the wheel. let partsOff = s.partsOff ?? []; let detachCD = Math.max(0, (s.detachCD ?? 0) - dt); let hp = s.hp ?? 100; let hitFlash = Math.max(0, (s.hitFlash ?? 0) - dt); const prevSpeed = s.prevSpeed ?? speed; const impact = prevSpeed - speed; // m/s scrubbed off this frame let wreckSpin = s.wreckSpin; // --- Wall bonk --- a genuinely hard planar slam while planted gets a crunch, // a tap of shake, AND chips your health: ram a wall and you pay for it. Harder // hits hurt more (parts start tearing off as hp drops). No launch or spin — // you keep driving, just battered. Cooldown keeps a scrape from machine-gunning // the sound; landGraceT gates it out on a touchdown so a landing never bonks. let bonkCD = Math.max(0, (s.bonkCD ?? 0) - dt); const prevVel = s.prevVelMag ?? velMag; const planarDrop = prevVel - velMag; // sudden loss of planar momentum (bounce / slam) const wedged = (s.gas ?? 0) > 0.4 && velMag < 3 && prevVel > 6; // flooring straight into a wall that stopped you const hardSlam = (impact > 5 && prevSpeed > 6) || planarDrop > 5; if (bonkCD <= 0 && groundedWheels > 0 && landGraceT <= 0 && (hardSlam || wedged)) { bonkCD = 0.45; const feet = objectApi.getProperty("feetPosition") || { x: 0, y: 0, z: 0 }; const force = Math.max(impact, planarDrop, wedged ? 8 : 0); const hard = Math.min(1, force / 16); objectApi.playSound("/cdn/moodboard-supertux-sunny-circuit/sfx-wall-crash.mp3", { position: { x: feet.x, y: feet.y, z: feet.z }, volume: 0.7, pitch: 0.98 - hard * 0.14, audience: { kind: "place" }, }); if (s.driverId) objectApi.screenShake(0.1 + hard * 0.16, 0.16, { audience: { kind: "player", id: s.driverId } }); // The crunch costs you: a scrape chips a little, a full-speed slam really hurts. const dmg = Math.round(5 + hard * 20); hp = Math.max(0, hp - dmg); hitFlash = 0.5; detachCD = 0.8; // pause self-repair so the hit reads before it mends objectApi.damageNumber({ x: feet.x, y: feet.y + 1.4, z: feet.z }, dmg, { color: "oklch(0.8 0.18 40)", size: 1.7, audience: { kind: "place" } }); objectApi.particleBurst({ x: feet.x, y: feet.y + 0.4, z: feet.z }, "smoke", { scale: 0.5 + hard * 0.5, color: "oklch(0.85 0.04 60)", audience: { kind: "place" } }); // Kick back off the wall — kill the forward charge, then bounce the kart clear // so you're never pinned grinding into it. Bigger slam, bigger rebound. objectApi.setVelocity(0, 0, 0); objectApi.addImpulse(-fwdX * mass * (5 + hard * 7), mass * 3, -fwdZ * mass * (5 + hard * 7)); } // Battered yourself into a wall down to zero? That's a self-destruct knockout — // same explosion + 1s respawn, just no point for anyone (no killer). if (hp <= 0 && (s.driverId || s.aiDriver) && !s.koExploding) { triggerKO(objectApi, null); return; } // No passive self-repair: battle damage STICKS. Health only drops (punches, rams, // wall bonks) until it hits zero — that's a knockout, which refreshes the kart to // full right where it sits and banks a point for whoever landed the finishing hit. // --- Reconcile parts to health --- each part falls off below its threshold and // pops back on once health climbs over it, so what's missing tells you how hurt // the kart is. Debris + crunch only fire on the frame a part newly tears loose. if (s.shellId) { const off = new Set(partsOff); const feet = objectApi.getProperty("feetPosition"); let spawnedDebris = 0; for (const part of DETACHABLE) { const shouldBeOff = hp < part.threshold; const id = s.shellId + "/" + part.suffix; // Re-assert visibility every frame so a single missed render can't leave a // part stuck hidden after it should have mended back on. objectApi.setObjectProperty(id, "visible", !shouldBeOff); if (shouldBeOff && !off.has(part.suffix)) { if (spawnedDebris < DEBRIS_SPAWN_CAP) { spawnedDebris++; const sideSign = objectApi.random() < 0.5 ? 1 : -1; const rX = -fwdZ * sideSign, rZ = fwdX * sideSign; objectApi.spawn("debris-" + part.suffix + "-" + Math.floor(objectApi.random() * 99999), { tags: ["debris"], behavior: ["scripts/debris.js"], state: { vx: vel.x * 0.5 + rX * 4, vy: 5, vz: vel.z * 0.5 + rZ * 4 }, properties: { feetPosition: { x: feet.x, y: feet.y + 0.4, z: feet.z }, primitive: part.prim, // Body panels shed in the kart's own paint, not the default red. material: part.body ? { color: s.bodyColor || "oklch(0.58 0.22 28)", roughness: 0.4 } : part.mat, physics: { body: "dynamic", mass: 1.2, restitution: 0.45, angularDamping: 0.2 }, }, }); objectApi.particleBurst({ x: feet.x, y: feet.y + 0.35, z: feet.z }, "smoke", { scale: 0.8, audience: { kind: "place" } }); objectApi.playSound("/cdn/moodboard-supertux-sunny-circuit/sfx-kart-panel-clatter.mp3", { position: { x: feet.x, y: feet.y, z: feet.z }, volume: 0.4, audience: { kind: "place" } }); if (s.driverId) objectApi.screenShake(0.4, 0.25, { audience: { kind: "player", id: s.driverId } }); } off.add(part.suffix); } else if (!shouldBeOff && off.has(part.suffix)) { off.delete(part.suffix); } } partsOff = [...off]; } // Brakes / handbrake const braking = (s.brake ?? 0) > 0; const coasting = Math.abs(gas) < 0.1 && !driftInput; if (driftInput) { objectApi.setWheelBrake(0, 0); objectApi.setWheelBrake(1, 0); objectApi.setWheelBrake(2, HANDBRAKE_REAR); objectApi.setWheelBrake(3, HANDBRAKE_REAR); } else if (braking) { for (let i = 0; i < 4; i++) objectApi.setWheelBrake(i, BRAKE_FORCE * tune.brake); } else if (coasting) { for (let i = 0; i < 4; i++) objectApi.setWheelBrake(i, ENGINE_BRAKE); } else { for (let i = 0; i < 4; i++) objectApi.setWheelBrake(i, 0); } // --- Carve engage: little hop + lock a direction --- const wasDrifting = s.wasDrifting ?? false; let skidDir = s.skidDir ?? 0; if (driftInput && !wasDrifting && speed > 3 && groundedWheels > 0) { objectApi.addImpulse(0, HOP_IMPULSE, 0); // break traction with a hop skidDir = steerAbs > 0.1 ? Math.sign(steerInput) : 0; } // If we engaged straight, lock the direction the moment the player steers. if (driftInput && skidDir === 0 && steerAbs > 0.1) skidDir = Math.sign(steerInput); if (!driftInput) skidDir = 0; const carving = driftInput && skidDir !== 0 && speed > 5; // --- Power-slide charge --- const driftActive = carving; let charge = s.driftCharge ?? 0; if (driftActive) { charge += dt; const stage = charge >= DRIFT_STAGE3 ? 3 : charge >= DRIFT_STAGE2 ? 2 : charge >= DRIFT_STAGE1 ? 1 : 0; if (stage > 0) { const feet = objectApi.getProperty("feetPosition"); // rear exhaust point + two pipes spread laterally const rightX = -fwdZ, rightZ = fwdX; // Soft tire smoke billowing low off the rear wheels — pale, only faintly // tinted by the charge stage so the build-up still reads at a glance. const baseX = feet.x - fwdX * 0.85, baseZ = feet.z - fwdZ * 0.85, baseY = feet.y + 0.12; const col = stage === 3 ? "oklch(0.9 0.05 255)" : stage === 2 ? "oklch(0.92 0.05 60)" : "oklch(0.94 0.02 90)"; const sc = stage === 3 ? 0.6 : stage === 2 ? 0.5 : 0.4; // Stagger the two puffs across alternating ticks so it stays a gentle haze, // not a dense double-stream — softer look and lighter per-frame. const side = (objectApi.random() < 0.5) ? -0.4 : 0.4; objectApi.particleBurst({ x: baseX + rightX * side, y: baseY, z: baseZ + rightZ * side }, "smoke", { scale: sc, color: col, audience: { kind: "place" } }); } } else { if (charge >= DRIFT_STAGE1) { const stage = charge >= DRIFT_STAGE3 ? 3 : charge >= DRIFT_STAGE2 ? 2 : 1; const b = BOOST_IMPULSE[stage]; objectApi.addImpulse(fwdX * b, 0, fwdZ * b); const feet = objectApi.getProperty("feetPosition"); objectApi.particleBurst({ x: feet.x, y: feet.y + 0.4, z: feet.z }, "fire", { scale: 0.7, color: "oklch(0.75 0.2 255)", audience: { kind: "place" } }); objectApi.playSound("/cdn/moodboard-supertux-sunny-circuit/sfx-turbo-boost.mp3", { position: { x: feet.x, y: feet.y, z: feet.z }, volume: 0.7, audience: { kind: "place" } }); } charge = 0; } // Rear friction (scaled by the kart's grip personality) let rearFriction = GRIP * tune.grip; const driftSustain = wasDrifting && isSliding; if (driftInput) rearFriction = DRIFT_REAR; else if (driftSustain) rearFriction = DRIFT_HOLD + (GRIP * tune.grip - DRIFT_HOLD) * (1 - Math.abs(gas)); if (landSkidT > 0) rearFriction *= 0.55; // roll out of a landing, don't bite objectApi.setWheelFrictionSlip(2, rearFriction); objectApi.setWheelFrictionSlip(3, rearFriction); // Front friction (counter-steer grip) let frontFriction = GRIP * tune.grip; if ((driftInput || driftSustain) && steerAbs > 0.1) { const counter = (slipAngle > 0 && steerInput > 0) || (slipAngle < 0 && steerInput < 0); if (counter) frontFriction = COUNTER_GRIP; } if (landSkidT > 0) frontFriction *= 0.7; // glide the nose through touchdown objectApi.setWheelFrictionSlip(0, frontFriction); objectApi.setWheelFrictionSlip(1, frontFriction); // Speed-sensitive steering const t = Math.exp(-STEER_SPEED_FACTOR * speed); const maxSteer = (STEER_MIN + (STEER_MAX - STEER_MIN) * t) * tune.steer; let targetSteering; if (carving) { // Committed carve: a tight arc in the locked direction. Steering INTO the // skid tightens it, counter-steer opens it back up. Ramps in over SKID_RAMP. const into = steerInput * skidDir; // +1 into, -1 counter const tightness = SKID_TURN_BASE + SKID_TURN_MOD * into; const ramp = Math.min(1, (charge) / SKID_RAMP); const carveMag = maxSteer * (1 + (tightness - 1) * ramp); targetSteering = -skidDir * carveMag; } else { targetSteering = -maxSteer * steerInput; } const newSteering = (s.currentSteering ?? 0) + (targetSteering - (s.currentSteering ?? 0)) * STEER_LERP; objectApi.setWheelSteering(0, newSteering); objectApi.setWheelSteering(1, newSteering); // --- Visual lean (SuperTuxKart graphical skid rotation) --- // Yaw the body shell into the slide. Physics body untouched — pure look. let vSkid = s.visualSkid ?? 0; const targetVSkid = carving ? -skidDir * VISUAL_SKID_MAX * Math.min(1, 0.45 + charge / SKID_RAMP) : 0; vSkid += (targetVSkid - vSkid) * VISUAL_SKID_LERP; if (s.shellId && Math.abs(vSkid - (s.visualSkid ?? 0)) > 0.001) { objectApi.setObjectProperty(s.shellId, "rotation", quatYaw(vSkid)); } // --- Drift screech --- a short tire-skid one-shot, cooldown-gated so a long // carve keeps chirping without ever leaving a loop hanging. (A tracked loop got // double-started across client/server and orphaned on state sync — gone for good.) let skidCD = Math.max(0, (s.skidCD ?? 0) - dt); const wantSkid = carving && groundedWheels > 0 && s.driverId && wreckT <= 0; if (wantSkid && skidCD <= 0) { objectApi.playSound("/cdn/moodboard-supertux-sunny-circuit/sfx-kart-tire-skid.mp3", { volume: 0.6, audience: { kind: "player", id: s.driverId }, }); skidCD = 0.7; } // One-time cleanup: kill any loop left hanging by the previous loop-based version. if (s.skidSoundId) objectApi.stopSound(s.skidSoundId); const ctrlPrev = s.ctrlT || 0; objectApi.patchState({ ctrlT: (ctrlPrev > 0 && ctrlPrev < 7) ? ctrlPrev + dt : ctrlPrev, skidSoundId: null, skidCD, nitroTank: tank, currentSteering: newSteering, speed: Math.round(speed * 3.6), boost: Math.round((tank / NITRO_MAX) * 100), wasDrifting: driftInput, driftCharge: charge, driftStage: charge >= DRIFT_STAGE3 ? 3 : charge >= DRIFT_STAGE2 ? 2 : charge >= DRIFT_STAGE1 ? 1 : 0, skidDir, visualSkid: vSkid, partsOff, detachCD, hp, hitFlash, wreckT, wreckSpin, landGraceT, landSkidT, bonkCD, _engineParamTick: engineParamTick, engRpm, prevSpeed: speed, prevVelMag: velMag, }); // Steering wheel + visual wheel sync. These parts live under the shell node, so // their real ids are shellId-qualified (e.g. "kart-red/shell/wheel-0"). Writing // the bare id resolves one level too high and silently hits nothing. const sh = s.shellId; objectApi.setObjectProperty(sh + "/steer-wheel", "rotation", { pitch: 65, roll: newSteering * RAD2DEG * 2.5 }); for (let i = 0; i < WHEELS.length; i++) { const ws = objectApi.getWheelState(i); if (!ws) continue; const w = WHEELS[i]; const suspY = SUSP_REST - ws.suspensionLength; const steerDeg = i < 2 ? (ws.steering ?? 0) * RAD2DEG : 0; const spinDeg = (ws.rotation ?? 0) * RAD2DEG; const wheelRot = { yaw: steerDeg, pitch: spinDeg, roll: 90 }; const center = { x: w.x, y: w.y + suspY, z: w.z }; const feet = wheelFeetFromCenter(center, wheelRot); objectApi.setObjectProperty(sh + "/wheel-" + i, "rotation", wheelRot); objectApi.setObjectProperty(sh + "/wheel-" + i, "feetPosition", feet); objectApi.setObjectProperty(sh + "/hub-" + i, "rotation", wheelRot); objectApi.setObjectProperty(sh + "/hub-" + i, "feetPosition", feet); } }