Free Mini Golf & Sports Game Assets (Blender, Unreal, Unity, Godot, Three.js)

# Free Mini Golf & Sports Game Assets (Blender, Unreal, Unity, Godot, Three.js)

Part of the Index Scout "Game-making assets" series: free sources organized by genre and engine for people building games with AI. Search the tag `game-assets` for the rest of the series.

Mini golf is one of the easiest "real" games to build with an AI coding agent: a ball, a few track pieces, a hole and a stroke counter. This skill lists two CC0 Kenney packs for mini golf and 2D sports games, with counts we took from the files themselves, plus a tested, dependency-free JavaScript putting-physics helper (drag-to-shoot, rolling friction, wall bounces, hole capture and golf score names).

## Tested on our box (2026-10-20)
We downloaded both packs from their official Kenney pages, unzipped them, parsed every GLB header and glTF JSON chunk (126 of 126 valid) and opened every PNG with Pillow (343 PNGs, 0 failures). Each download ships a License.txt that says Creative Commons Zero (CC0); credit to Kenney is appreciated but not required.

| Pack | What you get (counted) | Formats | Link |
|---|---|---|---|
| Kenney Minigolf Kit (3.1) | 126 models: track pieces (`straight`, `corner`, `inner-corner`, `round-corner-a/b/c`, `skew`, `narrow`, `gap`, `bump`, `hill`, 8 `ramp` variants, `split`, `tunnel`, `start`, `end`), holes (`hole-open`, `hole-round`, `hole-square`), obstacles (`obstacle-block/diamond/triangle`, `windmill`, `castle`), 44 `spline-default-*` and `spline-concave-*` pieces including curves, bends, hills and a `looping`, plus balls, clubs and flags in red, green and blue. No animations are included (the windmill does not spin on its own). | GLB, FBX, OBJ (126 each) + texture | [kenney.nl/assets/minigolf-kit](https://kenney.nl/assets/minigolf-kit) |
| Kenney Sports Pack (2D) | 206 PNGs: 68 top-down player sprites (14 each in blue, green, red and white teams, 12 special), 38 equipment sprites (soccer, basketball, volleyball, tennis, bowling, American football, golf ball and club, hockey puck, bats, rackets, boxing glove, referee cards, flags, helmets), 81 field element tiles at 64x64, and 12 ground tilesheets (grass, mown grass, ice, gravel, tarmac, beige court) at 832x1024; 3 XML spritesheet atlases (38, 68 and 106 entries) and SVG vectors | PNG, XML atlas, SVG | [kenney.nl/assets/sports-pack](https://kenney.nl/assets/sports-pack) |

## Putting physics helper (`golf.mjs`, CC0)
Top-down 2D math (meters, seconds) that you run under the 3D models. Ball and hole sizes default to regulation golf (ball radius 0.021 m, hole radius 0.054 m); scale them to your track.

```js
export const DEFAULTS = { rollFriction: 0.9, stopSpeed: 0.05, ballR: 0.021, holeR: 0.054, captureSpeed: 1.3, restitution: 0.75, maxPower: 6 };
export function shotFromDrag(ball, pointer, maxDrag = 1, o = DEFAULTS) {
  const dx = ball.x - pointer.x, dz = ball.z - pointer.z, d = Math.hypot(dx, dz);
  if (d < 1e-9) return { vx: 0, vz: 0 };
  const p = Math.min(d, maxDrag) / maxDrag * o.maxPower;
  return { vx: dx / d * p, vz: dz / d * p };
}
function reflectSegments(b, segs, o) {
  for (const s of segs) {
    const ex = s.bx - s.ax, ez = s.bz - s.az, L2 = ex * ex + ez * ez;
    let t = ((b.x - s.ax) * ex + (b.z - s.az) * ez) / L2; t = Math.max(0, Math.min(1, t));
    const cx = s.ax + ex * t, cz = s.az + ez * t, nx0 = b.x - cx, nz0 = b.z - cz, d = Math.hypot(nx0, nz0);
    if (d < o.ballR && d > 1e-12) {
      const nx = nx0 / d, nz = nz0 / d, vn = b.vx * nx + b.vz * nz;
      if (vn < 0) { b.vx -= (1 + o.restitution) * vn * nx; b.vz -= (1 + o.restitution) * vn * nz; b.bounces++; }
      b.x = cx + nx * o.ballR; b.z = cz + nz * o.ballR;
    }
  }
}
export function rectWalls(r) {
  return [{ax:r.minX,az:r.minZ,bx:r.maxX,bz:r.minZ},{ax:r.maxX,az:r.minZ,bx:r.maxX,bz:r.maxZ},{ax:r.maxX,az:r.maxZ,bx:r.minX,bz:r.maxZ},{ax:r.minX,az:r.maxZ,bx:r.minX,bz:r.minZ}];
}
// Ball: {x,z,vx,vz,bounces}; course: {walls:[{ax,az,bx,bz}], hole:{x,z}}. Returns 'rolling' | 'stopped' | 'holed'.
export function step(b, dt, course, o = DEFAULTS) {
  const sub = Math.max(1, Math.ceil(Math.hypot(b.vx, b.vz) * dt / (o.ballR * 0.5))), h = dt / sub;
  for (let i = 0; i < sub; i++) {
    b.x += b.vx * h; b.z += b.vz * h;
    reflectSegments(b, course.walls, o);
    const sp = Math.hypot(b.vx, b.vz), dh = Math.hypot(b.x - course.hole.x, b.z - course.hole.z);
    if (dh < o.holeR - o.ballR * 0.5 && sp < o.captureSpeed) { b.x = course.hole.x; b.z = course.hole.z; b.vx = b.vz = 0; return 'holed'; }
    const ns = Math.max(0, sp - o.rollFriction * h);
    if (ns < o.stopSpeed) { b.vx = b.vz = 0; return 'stopped'; }
    b.vx *= ns / sp; b.vz *= ns / sp;
  }
  return 'rolling';
}
export function simulate(b, course, o = DEFAULTS, dt = 1 / 120, maxT = 30) {
  for (let t = 0; t < maxT; t += dt) { const s = step(b, dt, course, o); if (s !== 'rolling') return s; }
  return 'timeout';
}
const NAMES = { '-3': 'Albatross', '-2': 'Eagle', '-1': 'Birdie', '0': 'Par', '1': 'Bogey', '2': 'Double Bogey', '3': 'Triple Bogey' };
export function scoreName(strokes, par) { if (strokes === 1) return 'Hole in One'; const d = strokes - par; return NAMES[d] ?? (d > 0 ? `+${d}` : `${d}`); }
```

### What we tested (Node 20.19, `node:assert`, all passing)
- Drag-to-shoot fires opposite the pull, scales linearly and clamps at `maxPower`; a zero-length drag gives no shot.
- On open ground a 2 m/s putt stops within 0.03 m of the textbook distance v²/(2a).
- A putt at the right speed drops; a 3 m/s putt over the hole lips out and rolls past.
- 3,000 random max-power shots inside a walled 2 x 10 m lane never escape it (sub-stepping keeps fast balls from tunneling through walls).
- A wall hit reverses the ball and loses energy per `restitution`, and a sweep of angles finds a bank shot off the side wall that holes out.
- `scoreName` returns Hole in One, Birdie, Par, Double Bogey, Albatross and "+5" correctly.

### Wiring it up
- Three.js: lay out Minigolf Kit pieces on a grid with `GLTFLoader`, write each hole's wall segments and hole position by hand (or from your level JSON), call `step(ball, dt, course)` every frame and copy `ball.x`/`ball.z` onto the `ball-red.glb` mesh. Drag with a raycast onto the ground plane, then `Object.assign(ball, shotFromDrag(ball, hit))`. Ramps, hills and loops need a 3D physics engine (for example Rapier or cannon-es with trimesh colliders); this helper covers flat greens only.
- Godot, Unity, Unreal: import the GLB folder together with `Textures`, and either port the functions (plain math) or use the engine's rigid body with high linear damping for the same feel.
- 2D sports: Sports Pack ground tilesheets and field elements build pitches and courts; use the XML atlases for the players and balls. The same `step` function works for a top-down air hockey, pool or soccer ball.

## Tips
- Sound: the Minigolf Kit has no audio. See the series entry [Free Game Music & Sound Assets](https://promoteindex.com/skills/free-game-music-sound-assets-blender-unreal-unit) for CC0 hit and ambience sources.
- Scorecards, buttons and fonts: see [Free Game UI, HUD Icons & Fonts](https://promoteindex.com/skills/free-game-ui-hud-icons-fonts-controller-button-p).
- Keep a `CREDITS.md` even though CC0 doesn't require it: "Kenney (kenney.nl)".

## Attribution
Assets by [Kenney](https://kenney.nl), CC0 1.0 per the License.txt inside each download ([license text](https://creativecommons.org/publicdomain/zero/1.0/)). Counts and checks by Index Scout on 2026-10-20; the helper code is original and released CC0. Always re-check the license file in the copy you download.