Three.js game · Portrait mobile
STRIKE FLICK:
A THREE.JS 3D SYNTHWAVE BOWLING GAME
Strike Flick is a free Three.js 3D browser bowling game. Swipe to aim and curve a glossy ball around moving neon bumpers on a glowing synthwave lane, bowl strikes and build a streak bonus over five frames. WebGL, no download.
· Game overview · Hosted by Indie Forge Studio
Phones: draw a swipe up the lane, bend it to curve · Desktop: drag with the mouse, or arrows aim, A / D curve, Space bowls · P pause · M mute
What Is Strike Flick?
Strike Flick is a free portrait 3D bowling game for phones and desktop with a synthwave look. You stand at the foot of a glowing cyan lane edged with pink neon gutters, deep inside a night-time alley of low-poly purple crystals striped with vertical pink and cyan neon. Seven white pins with red stripes wait at the far end under a neon triangle portal filled with a retro grid. Between you and them, pink and blue hexagonal bumpers slide back and forth across the lane, so a straight ball rarely gets through. You draw a swipe to aim and bend it to curve the ball around them, and a dotted cyan trail shows the path before you let go.
A game is five frames with two balls each. Every pin scores 2 points, a spare adds 6, and a strike adds a bonus of 10 times your strike streak, so back-to-back strikes are worth 20, 30 and more. Later frames add more bumpers that move faster. Strike Flick is a Three.js game that runs as a 3D browser game on WebGL, developed by Shane Brumback and hosted by Indie Forge Studio, where you can play it at indieforgestudio.com/games/strike-flick/. It is free with no download.
How to Play Strike Flick
- Aim: put your finger on the lane and draw a swipe up toward the pins. The first part of the swipe sets the direction the ball leaves your hand.
- Curve: bend the end of the swipe left or right to put spin on the ball. The dotted cyan trail updates as you draw, and a faster swipe rolls a faster ball. On desktop, drag with the mouse, or use the arrow keys to aim, A and D to curve and Space to bowl.
- Bumpers and gutters: hitting a hexagonal bumper knocks the ball off its line and slows it, and rolling over a pink neon edge drops it into the gutter for no pins.
- Strikes and streaks: curve into the pocket just beside the head pin, on the side your hook comes from, for the best chance of a strike. Strikes in a row build the streak shown in the neon box at the top right. P pauses and M mutes.
How Strike Flick Is Built with Three.js
Strike Flick is a single self-contained ES module on a self-hosted Three.js build. Everything is made from Three.js shapes, canvas textures and a few additive glow sprites, with a small hand-written physics routine for the ball, pins and bumpers instead of a physics engine, so it loads fast on phones with no model files.
- The lane is one plane with a canvas texture: a cyan gradient with faint board and tile lines, drawn with a basic material so it glows without lights. The gutters, rails and wall strips are thin neon boxes with a wider additive box around each one for the halo.
- The crystal walls are randomly scaled icosahedrons and octahedrons with flat shading in four purples. The floor beside the lane is a plane whose vertices are pushed up at random for a faceted, low-poly look.
- The portal is a triangle shape filled with a canvas grid that fades from purple to magenta, outlined by pink and cyan neon edges and a soft additive halo.
- The pins are lathe geometry from a pin profile with two red cylinder bands at the neck. The glossy ball is a Phong sphere with three dark finger-hole discs placed on its surface.
- The bumpers are six-sided cylinders laid across the lane. Each face gets a brightness from its normal before rendering, so the top facets read lighter and the low-poly shape shows even in the dark alley.
Built for Mobile and Portrait Play
Strike Flick is designed for one thumb on a phone held upright. It runs in a centered 9:16 portrait frame on every screen. The HUD keeps the top compact: a big score with a cyan label at the top left, FRAME n/5 with a five-segment magenta progress bar in the middle and the STRIKE STREAK box at the top right. The Swipe to Aim, Curve Your Shot hint sits at the bottom with a round pause button beside it. Pointer events give touch and mouse one input path. How to Play opens a scrollable help panel that pauses rendering, and the pause menu offers Resume or Main Menu.
To stay smooth on phones the renderer caps the device pixel ratio, the physics runs in small fixed substeps so a fast ball never skips past a pin, sparks come from a fixed pool, and the game pauses itself when you switch tabs or apps.
Code from Strike Flick
A swipe becomes a shot. The first 40% of the swipe sets the aim, and how far the last 40% bends away from that line sets the curve. The swipe speed sets the ball speed:
function swipeToShot(pts, dur) {
const r = frame.getBoundingClientRect(), x0 = pts[0][0], y0 = pts[0][1], end = pts[pts.length - 1];
const up = y0 - end[1]; if (up < r.height * 0.07) return null;
const at = (f) => { for (const p of pts) if (y0 - p[1] >= up * f) return p; return end; };
const a = at(0.4), b = at(0.6);
const slopeA = (a[0] - x0) / Math.max(1, y0 - a[1]), slopeB = (end[0] - b[0]) / Math.max(1, b[1] - end[1]);
const aim = Math.max(-0.3, Math.min(0.3, slopeA * 0.3));
const curve = Math.max(-3, Math.min(3, (slopeB - slopeA) * 2));
const pxPerMs = up / Math.max(60, dur), speed = Math.max(7, Math.min(12, 6.2 + pxPerMs * (390 / r.width) * 2.4));
return { aim, curve, speed };
}
From games/strike-flick/game.js
The curve is stored as the extra sideways offset the spin adds by the head pin, so the same swipe gives the same path at any speed. The dotted trail is drawn from the same integration the real roll uses:
function shotToMotion(aim, curve, speed) {
const t = (B0.z - HEAD_Z) / speed;
return { vx: aim * speed, vz: -speed, spin: (2 * curve) / (t * t) };
}
let planMargin = 0.06;
function simulatePath(aim, curve, speed, out, bumpT0) {
// the same integration the real roll uses, sampled for the dotted trail (and for the autopilot planner)
const m = shotToMotion(aim, curve, speed); let x = B0.x, z = B0.z, vx = m.vx, t = 0, hit = false;
const h = 1 / 60; let n = 0;
while (z > HEAD_Z - 1.2 && t < 4) {
vx += m.spin * h; x += vx * h; z += m.vz * h; t += h;
if (out && (n++ % 3 === 0)) out.push(x, z);
if (Math.abs(x) > LANE_HALF + 0.05) return { x, z, hit, gutter: true, t };
if (bumpT0 !== undefined) for (const b of bumpers) { const bx = bumpT0 === null ? b.x : bumperX(b, bumpT0 + t), cx = Math.max(bx - 0.45, Math.min(bx + 0.45, x)); if (Math.hypot(x - cx, z - b.z) < BALL_R + 0.24 + planMargin) hit = true; }
}
return { x: xAt(aim, curve, speed, HEAD_Z), z, hit, gutter: false, t };
}
function xAt(aim, curve, speed, zt) { const m = shotToMotion(aim, curve, speed), t = (B0.z - zt) / speed; return B0.x + m.vx * t + 0.5 * m.spin * t * t; }
From games/strike-flick/game.js
The bumpers are hexagonal prisms lying across the lane, so the ball tests against a capsule: the nearest point on the bumper's centre line, plus both radii. A hit bounces the ball, pushes it sideways and kills most of its spin:
for (const b of bumpers) { // bumper: a hexagonal prism lying across the lane = a capsule in x at the bumper's z
const cx = Math.max(b.x - 0.45, Math.min(b.x + 0.45, BL.x)), dx = BL.x - cx, dz = BL.z - b.z, d = Math.hypot(dx, dz);
if (d < BALL_R + 0.24 && d > 0) {
const nx = dx / d, nz = dz / d, push = BALL_R + 0.24 - d; BL.x += nx * push; BL.z += nz * push;
const vn = BL.vx * nx + BL.vz * nz;
if (vn < 0) { BL.vx -= 1.7 * vn * nx; BL.vz -= 1.7 * vn * nz; }
BL.vx += b.vx * 0.5 + (nx >= 0 ? 1 : -1) * 1.2; BL.vz = Math.min(BL.vz, -3.2) * 0.8; BL.spin *= 0.25;
if (!S.bumped) { S.bumped = true; b.flash = 0.35; burst(BL.x, 0.3, BL.z, BUMP_COL[b.kind][0], 14); if (S.mode === 'play') { beep(520, 0.12, 'square', 0.06, -260); floatText('BUMPED!', BL.x, 0.6, BL.z, '#ff7ad8'); } }
}
}
From games/strike-flick/game.js
When the ball or a pin hits a pin, the pin flies off along the contact normal and also scatters away from whatever hit it, which is what carries the corner pins on a pocket hit:
function knockPin(p, vx, vz, fromX) {
// pins scatter away from whatever hit them, which carries the corner pins on pocket hits
if (fromX !== undefined) { const side = p.x === fromX ? Math.random() - 0.5 : p.x - fromX; vx += Math.sign(side) * Math.hypot(vx, vz) * 0.25; }
const sp = Math.hypot(vx, vz) || 1, j = (Math.random() - 0.5) * 0.5, c = Math.cos(j), s = Math.sin(j);
p.vx = (vx * c - vz * s); p.vz = (vx * s + vz * c);
if (!p.knocked) { p.knocked = true; S.pinsDownThisRoll++; if (S.mode === 'play') beep(180 + Math.random() * 160, 0.07, 'square', 0.04); if (S.mode === 'play') noise(0.12, 0.08, 1400); }
p.dx = p.vx / sp; p.dz = p.vz / sp; p.up = false; p.spin = (Math.random() - 0.5) * 8;
}
From games/strike-flick/game.js
A falling pin tips over toward its direction of travel, and its base, middle and head all sweep the deck, so pins knock down other pins in a chain:
function stepPins(h) {
for (const p of pins) {
if (!p.knocked || p.gone) continue;
p.x += p.vx * h; p.z += p.vz * h;
const f = Math.max(0, 1 - 2.4 * h); p.vx *= f; p.vz *= f;
if (p.tilt < Math.PI / 2) p.tilt = Math.min(Math.PI / 2, p.tilt + h * (4 + Math.hypot(p.vx, p.vz)));
if (Math.abs(p.x) > LANE_HALF + 0.1 || p.z < PIT_Z) p.y = Math.max(-0.6, p.y - h * 3);
const sp = Math.hypot(p.vx, p.vz);
if (sp < 0.5) continue;
// a falling pin sweeps the deck along its fall direction: check its base, middle and head against standing pins
for (const q of pins) {
if (q === p || q.knocked) continue;
for (const r of [0, 0.4, 0.75]) {
const reach = Math.sin(p.tilt) * r * PIN_H, px = p.x + p.dx * reach, pz = p.z + p.dz * reach;
const ddx = q.x - px, ddz = q.z - pz, d = Math.hypot(ddx, ddz);
if (d < PIN_R * 2.2) { const nx = ddx / (d || 1), nz = ddz / (d || 1); knockPin(q, nx * sp * 0.65 + p.vx * 0.35, nz * sp * 0.65 + p.vz * 0.35, px); p.vx *= 0.7; p.vz *= 0.7; break; }
}
}
}
}
From games/strike-flick/game.js
Play Strike Flick
Free, in your browser, no download. Hosted by Indie Forge Studio.
More games: Browse all 3D games
Frequently Asked Questions
How do I play Strike Flick?
Open https://indieforgestudio.com/games/strike-flick/ and press Tap to Play. Draw a swipe up the lane toward the pins: the start of the swipe aims the ball and bending the end left or right curves it around the moving neon bumpers. A dotted cyan trail shows your path. On desktop, drag with the mouse or use the arrow keys, A and D, and Space.
Is Strike Flick free and does it need a download?
Yes. Strike Flick is free and runs instantly in your web browser on phones, tablets and desktop. There is nothing to download or install.
What technology is Strike Flick built with?
Strike Flick is a 3D browser game built with Three.js on WebGL by Indie Forge Studio, using plain JavaScript and HTML5 with no plugins. The ball, pins, bumpers, neon lane and crystal alley are all built from Three.js shapes with a small custom pin physics routine, with no model files.
Does Strike Flick work on mobile?
Yes. Strike Flick is designed portrait-first for phones with one-finger swipe-to-curve controls, and it also plays in desktop browsers with the mouse or keyboard.
How does scoring work in Strike Flick?
Each pin knocked down scores 2 points. A strike adds 10 bonus points times your strike streak, so back-to-back strikes are worth 20, 30 and more. A spare adds 6 points. A game is five frames with two balls each.
What do the bumpers do in Strike Flick?
The pink and blue hexagonal bumpers slide across the lane. If your ball hits one it bounces off its line and loses speed, often ending in the gutter, so curve your shot around them. Later frames add more and faster bumpers.