Free Pirate & Naval Game Assets (Blender, Unreal, Unity, Godot, Three.js)

# Free Pirate & Naval 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.

Pirate and sailing games are a popular thing to build with an AI coding agent right now: a ship, an ocean, some islands, cannons and a treasure chest. This skill lists three CC0 packs that cover that in 3D and 2D, with numbers we got from the files themselves, plus a tested, dependency-free JavaScript helper for floating ships on Gerstner waves, picking a broadside and aiming cannons.

## Tested on our box (2026-10-20)
We downloaded each pack from its official Kenney page, unzipped it, counted the files, parsed every GLB header and glTF JSON chunk, and opened every PNG with Pillow (530 PNGs across the three packs, 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 Pirate Kit (2.1) | 72 models: `ship-pirate-large/medium/small`, `ship-ghost`, `ship-wreck`, plain ships, row boats, `cannon`, `cannon-mobile`, `cannon-ball`, `chest` (with `open`, `close`, `open-close` animations), barrels, crates, bottles, pirate flags, masts, palms, sand/grass patches, rocks, docks and platforms, castle walls/gate/door, towers and a watch tower, shovel and paddle | GLB, FBX, OBJ (72 each) | [kenney.nl/assets/pirate-kit](https://kenney.nl/assets/pirate-kit) |
| Kenney Watercraft Kit (2.1) | 46 models: sail boats, speed boats (10 variants), tug, tow, fishing and house boats, cargo ships and containers, ocean liners, `buoy`, `buoy-flag`, race `gate`, `gate-finish`, ramps and arrows | GLB, FBX, OBJ (46 each) | [kenney.nl/assets/watercraft-kit](https://kenney.nl/assets/watercraft-kit) |
| Kenney Pirate Pack (2D, top-down) | 403 PNGs: 30 ships and dinghies, 67 ship parts (hulls, 24+ sails, flags, crew, cannons, cannon balls, crow's nest), 96 sea/island tiles at 64x64, 5 effects (explosions, fire), each at default and retina size; spritesheet with 102 entries (XML atlas) and a 1024x384 tilesheet (16x6 tiles) plus SVG vectors | PNG, XML atlas, SVG | [kenney.nl/assets/pirate-pack](https://kenney.nl/assets/pirate-pack) |

Also worth a look but not downloaded by us: [Quaternius Pirate Kit](https://quaternius.com/packs/piratekit.html), whose page lists 71 models in FBX, OBJ, Blend and glTF under CC0 (the download is a Google Drive folder).

### Things we noticed in the files
- The Kenney 3D GLBs are not self-contained: each one points to `Textures/colormap.png`. Copy the `Textures` folder next to the GLB folder or the models load untextured.
- Vertex bounds of `ship-pirate-large` are about 4.8 wide, 10 tall and 13.1 long (units, length along Z); `ship-pirate-small` is about 8.8 long and `cannon` about 2.4 long. Ships and props share one scale, so you can mix them without rescaling.
- The large pirate ship has separate nodes for `sail-a`, `sail-b` and its flags, so you can sway or hide sails in code.
- `chest` is the only animated model in the Pirate Kit (open/close clips), which is enough for a treasure pickup.
- The Watercraft `ship-large` has the same bounds as the pirate `ship-large`, so the two kits sit at the same scale.

## Ocean and broadside helpers (tested in Node 20)
Save as `pirate.mjs`. No dependencies. Use the same `WAVES` array in your water vertex shader so ships ride the wave the player sees.

```js
const G = 9.81;
export const WAVES = [ // [wavelength m, steepness, direction radians]
  [46, 0.085, 0.0], [27, 0.10, 0.38], [15.5, 0.12, -0.52], [8, 0.10, 1.1],
];
function waveTerms(x, z, t, waves) {
  let dx = 0, dy = 0, dz = 0;
  for (const [L, Q, dir] of waves) {
    const k = 2 * Math.PI / L, c = Math.sqrt(G / k), A = Q / k;
    const Dx = Math.cos(dir), Dz = Math.sin(dir);
    const f = k * (Dx * x + Dz * z - c * t);
    dx += Dx * A * Math.cos(f); dz += Dz * A * Math.cos(f); dy += A * Math.sin(f);
  }
  return [dx, dy, dz];
}
// Gerstner waves move points sideways, so iterate to find the grid point that lands on (x, z).
export function heightAt(x, z, t, waves = WAVES, iters = 4) {
  let px = x, pz = z;
  for (let i = 0; i < iters; i++) {
    const [dx, , dz] = waveTerms(px, pz, t, waves);
    px = x - dx; pz = z - dz;
  }
  return waveTerms(px, pz, t, waves)[1];
}
// Sample bow, stern, port and starboard: returns y, pitch (bow up +) and roll (port up +).
export function shipPose(x, z, heading, t, length = 13, beam = 4.8, waves = WAVES) {
  const fx = Math.sin(heading), fz = Math.cos(heading), rx = -fz, rz = fx; // forward, starboard (Y up)
  const h = (ox, oz) => heightAt(x + ox, z + oz, t, waves);
  const bow = h(fx * length / 2, fz * length / 2), stern = h(-fx * length / 2, -fz * length / 2);
  const stbd = h(rx * beam / 2, rz * beam / 2), port = h(-rx * beam / 2, -rz * beam / 2);
  return { y: (bow + stern + stbd + port) / 4,
           pitch: Math.atan2(bow - stern, length), roll: Math.atan2(port - stbd, beam) };
}
// Which broadside can fire? arcDeg = half-width of the firing arc around the beam.
export function broadside(ship, target, arcDeg = 35) {
  const fx = Math.sin(ship.heading), fz = Math.cos(ship.heading);
  const tx = target.x - ship.x, tz = target.z - ship.z, dist = Math.hypot(tx, tz);
  const fwd = (fx * tx + fz * tz) / dist, side = (fx * tz - fz * tx) / dist; // side > 0 = starboard
  const offBeamDeg = Math.abs(Math.asin(Math.max(-1, Math.min(1, fwd)))) * 180 / Math.PI;
  if (offBeamDeg > arcDeg) return { side: null, dist, offBeamDeg };
  return { side: side > 0 ? 'starboard' : 'port', dist, offBeamDeg };
}
// Low-arc elevation (radians) to hit flat range d with muzzle speed v; null = out of range.
export function cannonElevation(d, v, g = G) {
  const s = (g * d) / (v * v);
  return s > 1 ? null : 0.5 * Math.asin(s);
}
```

What our test script checked (all passed on Node v20.19.2, and the three.js check also used three r186): a flat sea returns height 0 and zero pitch/roll; after the drift correction the displaced surface point lands within 0.001 of the requested (x, z); 2,000 random samples stay inside the summed wave amplitude (1.48 m for these four waves); with heading 0 (facing +Z, Y up) a target on -X is starboard, on +X is port, dead ahead is out of arc, about 31 degrees off the beam is in a 35 degree arc and about 39 degrees is out; `cannonElevation` returns 45 degrees at maximum range, `null` past it, and an angle whose ballistic range matches the target to within 1e-6.

### Wiring it up
- Three.js: load `ship-pirate-large.glb` with `GLTFLoader`, then every frame `const p = shipPose(ship.x, ship.z, ship.heading, t)` and set `ship.position.y = p.y; ship.rotation.set(-p.pitch, ship.heading, p.roll, 'YXZ')` (we checked these signs with three.js r186 in Node: a bow-up pose raises the bow and a port-up pose raises the port side). In `ship-pirate-large.glb` the hull narrows to a 0.8-unit-wide bowsprit at +Z and is 4.4 wide at the -Z stern, so the bow faces +Z and heading 0 works as-is; for a model whose bow points to -Z, add Math.PI to the heading.. Put the same Gerstner sum in the water shader; three.js also has an [ocean example](https://threejs.org/examples/webgl_shaders_ocean.html) for the look.
- Godot, Unity, Unreal: import the GLB folder together with `Textures`, and port the four functions (they are plain math) to GDScript, C# or Blueprint/C++.
- 2D: use the Pirate Pack tilesheet for sea and islands, top-down ships from `Ships`, and swap `hullLarge`/`sailLarge` sprites for damage states. Drop the wave height and use only `broadside` and `cannonElevation` (or straight-line shots).
- For a deeper write-up of floating ships on Gerstner waves in plain three.js, see Balázs Csorba's [multiplayer sailing game post](https://balazscsorba.com/blog/multiplayer-sailing-game-threejs), which uses the same "one wave array for GPU and CPU" idea.

## Tips
- Cannons, explosions and ambient sea sound are not in these packs. See the series entry [Free Game Music & Sound Assets](https://promoteindex.com/skills/free-game-music-sound-assets-blender-unreal-unit) for CC0 audio sources (Kenney audio packs, OpenGameArt SFX and more).
- Islands: combine Pirate Kit palms, `patch-sand`, `rocks-sand-*` and docks; the dungeon and survival entries in this series add more props at a similar low-poly style.
- 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/)). Quaternius Pirate Kit license as stated on its page; we did not download it. 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.