Hive Hunger

A free 3D browser game: a swarm flies on its own, finds the nearest matter and eats planets made of voxels — mission by mission across the solar system, from the Kuiper Belt in to the Sun — alone (with a saved game), or with up to four players in Co-op or PvP.

Play: https://michalstankiewicz4-cell.github.io/Hive-Hunger/ · Version: 0.67.0 (changelog)

How the swarm behaves

The swarm moves like a flock of birds (boids): units keep their distance from each other, fly the same way as their neighbours and stay with the group. Every unit flies at the same constant speed — only its direction changes.

Eating is deliberate. Every unit claims the nearest uneaten, unclaimed voxel to itself (a "bite"), flies straight to it, lands on it and eats it, then picks the next nearest one — no free flying while eating, only a little spacing between units. One voxel is eaten by one unit only — bites are shared only when the planet has fewer exposed voxels left than there are units. Units never eat in passing. They don't bounce off matter or pass through it; they slide along the surface. The swarm target moves on once no free voxels are left nearby.

The page opens with a loader (the title and a progress bar over a blurred picture) while the start picture, the 3D engine, multiplayer and the game load; then the start screen: the picture of a voxel ship cutting into a voxel planet with the title and the menu (Single player, Co-op, PvP, Ship guide, Settings) beside it. The game starts from a map of the solar system (single player and multiplayer): the Sun in the middle, the orbits, the planets with their moons and two belts, in 3D, seen from above at an angle — drag to turn it, the wheel (or two fingers) to zoom. The missions go from the outside in: the Kuiper Belt (a long, very slightly bent band of small icy asteroids, seen at an angle), Pluto and Charon, Neptune and Triton, Uranus, Saturn and Titan, Jupiter, Europa and Io, the Asteroid Belt, Mars, Deimos and Phobos, Earth and the Moon, Venus, Mercury — and the Sun. A click on a body opens its card: a picture, what it is, the task and Start. For now two missions can be played — the Kuiper Belt and Earth (the usual planet); the other bodies are on the map as coming soon. In single player every playable mission is open; when a planet is eaten the ships jump to hyperspace and you are back on the map, the body ticked (remembered in this browser) and the next mission marked. In multiplayer the missions go in order — the map shows where the room is going, behind the waiting room and the summary. Every planet is drawn as a smooth surface: no steps — slopes, rounded corners and craters. It is graphics only: underneath, the swarm still eats voxels — every voxel is still 1 point.

When eating cuts a piece off — a part no longer connected to the rest — it comes loose: every part smaller than the rest gently drifts away and turns (parts of equal size all stay). It stops at most 4 units from where it came off, and big pieces turn slowly. A piece bitten through breaks up again the same way, and so on until it is eaten. The swarm can chase it and eat it like any other voxel, for the same points; a drone that hasn't eaten anything for 10 s stops for half a second and takes another bite (or the same one, if there is no other). A planet counts as eaten only when its last voxel is gone, drifting pieces included. The ships then escape into hyperspace — one after another at random moments (several at once in a big swarm), each speeding off with a blue streak behind it — and the next planet appears once they are all gone. Ships arrive through a subspace tunnel at the spawn point: it opens into a wide blue vortex, the ships fly out of it, and it closes to a small swirl (click it to call the swarm back; it opens for a moment to take in a piece a tug brings home). The camera never turns by itself — only when you turn it.

Hive Carrier

Beyond the Kuiper Belt on the solar system map waits the Hive Carrier, your mothership (its bow to the left and a little down) — a heavy voxel carrier five times as long as Earth is wide. Click it (instead of a mission): its card shows it from above, and Go aboard shows it full size (drag to turn, wheel to zoom; Back or Esc to the map) with its modules — hull, bridge, reactor, engines, flight deck, hangar bay, hive modules, refinery, sensor array — all operational for now (later they will be repaired one by one). A patchwork of greys with yellow touches; a dark flight deck overgrown with honeycomb like a wild hive — patches of different heights flowing into each other, cells capped with light wax, glowing with honey or open and dark — with a few ships parked between them; a stepped command tower with blue windows and antennas; nine big yellow honeycomb modules along each side, their small cells glowing; the bow's hangar mouth framed in honeycomb with a lit hall inside; four great blue nozzles in two pairs at the stern; its lights light up the hull round them — rows of windows go out now and then and the hull there darkens, honey breathes, nozzles pulse; tanks for water, lava and gas under the keel; blinking running lights. Aboard, above the modules, its storage: what your missions collected, by kind of voxel (each finished mission adds its haul; saved with the game), and processing: Smelt rock — 50 rock → 5 iron + 45 waste; Fuse water and lava — 1 water + 1 lava → 5 iron (Process: once, Shift: 10 times; off while the storage hasn't enough; nothing uses the waste yet). It is only on the single-player map: during a mission (and in multiplayer) it is not seen.

Enemy ships

Round Earth and the test board fly 10 enemy ships (single player, for now): red cones with a glass cockpit and an engine glow, as big as your ships, each on its own tilted orbit between the planet and the tunnels. When your ships come within range they fire glowing red bolts at them, aimed ahead of where the ship is flying; a ship takes 3 hits (a red spark each) and then it is gone. Your attack ships (the ship bar's Attack group, not eaters) fire back: a beam in their colour at an enemy within range, about once a second; an enemy takes 8 beams, flashes white when hit and bursts into debris at the last one.

Points and upgrades

Every eaten voxel is 1 point (counter at the top). Tab (or a click on the counter) opens the upgrade tree, growing upwards over levels 0–5 with links across branches: traits of the whole swarm (diamonds) — Brood (+units), Wings (+speed), Jaws (+bite radius) and Chain lightning (a bolt that jumps between your drones every few seconds and weakens the voxels on its way, with Arcs, Voltage and Capacitor) — and every ship type (hexagons) with its own properties (small circles). For now the ships, their properties, Agility and Swarm sense are coming soon. Upgrades add to your swarm's base values (Brood adds ships). Voxels show damage as they are eaten: the surface sinks in and darkens before the voxel breaks apart.

Controls

• Ship bar (along the bottom) — a thumbnail of every ship type with how many you have. Click a thumbnail to choose that group (one at a time; eaters at first; it stays chosen). + on a thumbnail buys one ship of that type (Shift: 10) — free for now — up to 100 ships in all; it comes out of your tunnel (the tunnel opens, the ship flies out). − sends one away (Shift: 10): it jumps to hyperspace like at the end of a planet and is gone; every ship can go, the last one too (one still in the tunnel is gone at once). When not all the ships fit on the screen, ◀ ▶ at the ends of the bar scroll it. You start with 3 eaters and nothing else
• Click / tap a voxel (the planet, an asteroid or a drifting piece) — send the chosen group there (a pulsing ring marks the spot): only those ships drop their bites and their next bites are the voxels nearest to it; ships that don't eat (tugs, support, cleaners, boosters) fly there and then carry on as usual. The other groups go on with what they were doing. Clicks into empty space do nothing. A unit stuck in a corner of a crater or tunnel bites through the blocking voxel (if it isn't someone else's) and carries on
• Click the tunnel (the small blue vortex at the spawn point) — call the chosen group back home; it stops eating and waits there until you send it out again
• Right mouse button / two fingers — turn the camera, any way round (it can go over the poles)
• Mouse wheel — zoom
• Tab (or a click on the points counter) — upgrade tree (Esc closes it); in single player the game stands still while it is open
• M — single player, during a mission: the solar system map (the game pauses; nothing is saved). M, Esc or Back to it carry on; Start on another body leaves this mission for it (the game saves itself only when a mission is done)
• Collected — under the planet's name (top left), one under another: what you have collected of this planet so far, by kind of voxel (rock, water, iron, lava, gas — a coloured dot and how many); liquids and gas count once siphons and scoops take them in. Points stay as they are: a voxel, a point
• The solar system map — drag turns it, the wheel (or two fingers) zooms; a click on a body opens its card. A click on a planet with moons (or on one of its moons) zooms in on that planet and its moons, following it round its orbit — Back or Esc shows the whole system again (so does a click on anything else)

Multiplayer

The start screen offers Single player, Multiplayer · Co-op and Multiplayer · PvP. Choosing a multiplayer mode opens a room: click Copy link and send it — others join by opening the link (up to 4 players). A room always starts from scratch — the first mission (the Kuiper Belt), no points or upgrades — even if you were playing single player before (only the number of your ships stays). The match begins when every player in the room has pressed Start (Not ready takes it back).

• Co-op — everyone eats the same planet together; the scoreboard shows how many voxels each player has eaten (the summary after each planet shows the shares).
• PvP — a race on the same planet: whoever eats more of it wins the planet.

Every player has their own swarm (Blue, Pink, Green, Violet), tunnel and ship bar (buying and sending groups go through the host). After each planet a summary shows who ate how much of it (and in PvP who won it); the next planet comes once everyone has pressed Next planet. The scoreboard shows each player's ping (the host is marked "host"), the room panel shows your connection, and a short notice appears when someone joins, leaves or loses the connection. Spawn points are spread evenly around the planet (2 players opposite each other, 3 a third of a turn apart, 4 a quarter). It runs peer to peer over WebRTC (PeerJS); the host's browser runs the game. Details: docs/MULTIPLAYER.md.

Troubleshooting

• "Room not found" — the link is wrong or the room is closed (the host left or closed the tab). Ask the host for a new link.
• "This room is full" — the room already has 4 players.
• Stuck on "Joining…" or "Could not reach the connection server" — the PeerJS server that introduces the browsers could not be reached, or a strict network (some company, school or mobile networks) blocks direct connections between browsers. The game has no relay (TURN) server, so try another network.
• The game stopped for everyone — the host switched to another tab or minimised the browser; browsers pause games in background tabs. It continues when the host comes back.
• "Lost the connection to the host" / "…: connection lost" — no messages for 10 seconds or the connection broke without a goodbye (network drop, sleeping laptop). Rejoin with the same link while the room is open.
• A high ping next to a player means slow updates for that player; it doesn't slow down the others.

Running locally

The code uses ES modules, so it has to be served over HTTP (opening index.html straight from disk won't work):

npx serve .
# or
python -m http.server

Three.js r128 and PeerJS 1.5.4 are in the repository (js/vendor/), so the game loads nothing from the internet: single player works offline (from a local server). Multiplayer still needs the internet to find the other players.

Browser tests (single player and multiplayer with a local PeerJS server) are in tests/ — see tests/README.md.

Ship editor

tools/ship-editor.html (on the site: /tools/ship-editor.html) is a separate page for planning changes to the ships: values (Power, reach, speed, colours …), what each ship goes for first, the order of its tasks (standard ones from the game and your own), notes. Export saves a JSON file with every change, to be applied to the code; nothing in the game changes by itself. Open it through a local server or the site (it reads js/config.js).

Tree editor

tools/tree-editor.html (on the site: /tools/tree-editor.html) is a separate page for planning the upgrade tree: move nodes (drag: level and angle), add nodes on any level, connect two nodes (the same two again removes the link), and per node — its name, kind, branch, a ship, what should be there in your own words, the text in the game, the cost, whether it needs any or all parents, a colour from a palette of 16 (darker pastel versions of the ships' colours); the branches' colours from the same palette; notes. Export saves a JSON file with the whole tree and every change, to talk over and apply to the code. EN / PL.

Voxel editor

tools/voxel-editor.html is a separate page for planning kinds of voxels: rock (every voxel in the game today), water, iron, lava and your own — for each its name, colour, glow, see-through, strength, points, which ships can eat it, how it behaves (flows, falls, hurts ships, comes loose, fills holes back in), where it is and how much of it, on which bodies, and in your own words what it should do. Export saves a JSON file to talk over; nothing in the game changes. EN / PL.

Dev tools

Dev tools on the start screen: tiles for the ship editor, the tree editor and the voxel editor (each opens in a new tab), and the Test board — 5 balls 10 voxels across in two rows, one of each kind of voxel from the voxel editor (rock and water; iron, gas and lava), again and again (eaten: the ships jump and they are back at once), no ships at the start (buy them on the ship bar), nothing saved and no map ticks; water and lava are liquids — lava churns and glows, water ripples and glints, on the balls and on every droplet, each its own: a voxel of them eaten or destroyed floats away as a droplet (water thinner, lava thicker — the droplets gather into blobs, no gravity), gives no point, and only siphons can collect it; solid gas has soft marbled lilac, blue and pink bands that swirl (its loose pieces too) — eaten or destroyed it turns into a patchy cloud of wisps (each its own size, colours and pattern) that swells and spreads slowly, gives no point, and only scoops can take it in; the board (like a planet) is done only when every voxel is eaten and every droplet and puff taken in; Esc → Exit to main menu puts your ships back as they were at the start.

Documentation

• CHANGELOG.md — versions and what changed
• docs/ARCHITECTURE.md — folders and modules, how the big classes are split over files, the frame loop, the swarm, the planet and performance
• docs/MULTIPLAYER.md — rooms, roles and the network protocol
• docs/CONFIG.md — what the values in js/config.js do and what changing them does
• tests/README.md — running the browser tests
• CONTEXT.md — project context: decisions, publishing and testing, to pick the project up again

Project structure

index.html            page, search metadata (title, description, keywords, link previews, structured data)
og-image.jpg          1200×630 thumbnail for link previews: the start screen
favicon.svg, favicon-48.png, apple-touch-icon.png
sitemap.xml           sitemap for Google Search Console
.github/workflows/    GitHub Pages deployment
css/                  one stylesheet per part of the page (base, hud, panel, lobby, menu, summary, points, tree)
js/
  main.js               entry point: start screen, single player, hosting or joining a room
  config.js             all game and network parameters
  version.js            game version
  core/                 rules without graphics: Leader (the swarm's "brain"), SkillTree (upgrades)
  three/game/           Game3D (scene, roles, planets, frame loop) and its parts: input, destruction,
                        host, guest, hud; Player (one player's swarm, brain, tunnel, settings, score)
                        and its parts: arrival, ships, upgrades
  three/swarm/          Swarm3D (the flock: feeding, collisions, drawing) and its parts: ship types,
                        a guest's copy, hyperspace, laser and storm beams, tractor beams; steering
  three/planet/         VoxelPlanet and its parts (look, eating, search, runs, grid), its smooth surface,
                        drifting pieces (Fragments), level shapes (the belt of asteroids too)
  three/carrier/        the Hive Carrier: its voxels (modules) and how it is drawn
  three/effects/        lightning, support ships' bolts, orbs, black holes, debris, droplets and gas (and their grid)
  three/scene/          sky, the subspace tunnel at the spawn point, click marker
  three/textures.js     glow and gradient textures shared by the effects
  net/                  multiplayer host and guest over PeerJS, binary messages
  ui/                   HUD, ship bar, menus, summary, upgrade tree,
                        the solar system map
  solar.js, progress.js the map's bodies (outside in); single player's finished missions
  save.js               single player's saved game (one slot in this browser)
  utils/                noise, terrain colours, sky colours
  vendor/               Three.js r128 and PeerJS 1.5.4 (kept here: no CDN), their licences
img/start.jpg         the start screen picture
tools/ship-editor.html  the ship editor: plan changes to the ships and export them as JSON
tools/tree-editor.html  the tree editor: plan the upgrade tree (nodes, links, costs, colours) and export it as JSON
tools/voxel-editor.html the voxel editor: plan kinds of voxels (water, iron, lava …) and export them as JSON
docs/                 architecture, multiplayer and configuration docs
tests/                browser tests (Playwright): solo, multiplayer, levels, upgrade tree, fragments, ship, tree and voxel editors and a local PeerJS server
LICENSE               MIT

Almost all tunable values (planet size, voxel size, levels, flock weights, eating speed, network timing) live in js/config.js; upgrade costs and the lightning's base values are in js/core/SkillTree.js (see docs/CONFIG.md).

Search & sharing

The page has a search title and description, keywords, a canonical URL, Open Graph / Twitter link previews with og-image.jpg (the start screen), VideoGame structured data (JSON-LD: genres, single player / multiplayer / co-op, 1–4 players), and a sitemap. The page is in English; Polish keywords and a short Polish description (in the hidden text, lang="pl") help it be found in Polish searches too. Because the game is a 3D canvas, a short visually hidden description gives search engines text to index.

To get indexed faster, add the site in Google Search Console and submit https://michalstankiewicz4-cell.github.io/Hive-Hunger/sitemap.xml.

License

MIT © 2026 Michał Stankiewicz