Six playable art directions for a personal remake of Jim Rutt’s Network Wars. Every style runs the same rules engine, rebuilt from the original app’s decompiled logic. The bots are fighting below right now; switch to Play to take red.
Round 1
Dealing the board…
Gold takes the network
24 of 30 nodes on round 9.
Next map in a few seconds.
Mode
Map
Layout
Speed
Sound
Map #1
In Play, tap one of your red nodes holding 2+ armies, then a highlighted neighbour. After a capture the stack that moved stays selected so you can keep rolling. Enter ends your turn and M toggles sound. Drag to pan; pinch, Ctrl+scroll or double-click to zoom. The same map number always deals the same board.
Neon Grid
In production
How it works
The rules, recovered from the original app
Max Bittker’s remake goes further than most: he decompiled the shipped iOS app and recovered its battle, deal, bot and reinforcement code. The engine in this page re-implements those rules from his notes, and its capture odds match his published table to three decimals.
Board
30 nodes on a 6 × 7 grid: 42 cells with 12 removed at random, always leaving one connected network. Links run across, down and diagonally, so diagonal links can cross.
Factions
Five. You are red; green, gold, blue and purple move after you, always in that order.
The deal
Every faction starts with exactly 6 nodes and 20 armies. Two to five of those nodes are “big” and share the spare armies evenly (8-8, 6-6-5, 5-5-4-4 or 4-4-4-4-3); the rest hold 1. Big nodes are placed as touching pairs and triples.
Attacking
From any node with 2+ armies into an adjacent enemy, as many times as you like. You may attack anything; bots only attack nodes strictly weaker than the attacker.
Battle
Fair coin flips. The attacker gets two free shots, then both sides fire each round until the defender reaches 0 or the attacker is down to 1. On a capture every survivor but one moves in. Win or lose, the attacking node is left holding 1.
Reinforcement
After each turn, count the nodes in your largest connected group. You get that many armies, spread evenly over that group’s border nodes. Cut-off groups get nothing.
Bots
One pass per turn, strongest stack first. Each stack hits its weakest neighbour if it is strictly bigger, and keeps going with the stack that just captured until it is repelled. No randomness in their choices.
Winning
First faction to hold 24 nodes (80%) wins. You lose if you are wiped out.
Chance the attacker captures
Rows: attacking armies. Columns: defending armies. Exact values from the coin-flip recurrence, not simulation.
Three things worth knowing at the table: a 2-on-1 attack still fails one time in six; an even fight slightly favours the defender (44% at 2 v 2, approaching 50% for big stacks) because the attacker must keep one army back; and attacks become reliable at roughly 2 : 1.
Bigger maps
The rules scale; the turn length is what grows
The original map generator, makeIslandArrayDyno, already takes grid size, team count, nodes per team and starting armies as parameters. The shipped game just fixes them at 6 × 7, 5, 6 and 20. Battle, reinforcement and the bots have no size dependence at all. So larger maps are a matter of picking numbers that keep the classic ratios: about 3.3 armies per node, roughly half the nodes holding big stacks, and a win at 80% of the board. The lab’s Large and Epic presets do exactly that, and the Organic layout swaps the grid for a planar network with no crossing links.
Map
Nodes
Factions
Each starts with
Win at
Game length
Attacks per bot turn
Biggest stack
Mop-up rounds
Classic · grid
30
5
6 nodes · 20 armies
24
9 rounds
3.2
22
4.3
Classic · organic
30
5
6 nodes · 20 armies
24
8 rounds
3.4
12
3.7
Large · grid
60
5
12 nodes · 40 armies
48
10 rounds
4.5
54
8.8
Large · organic
60
5
12 nodes · 40 armies
48
9 rounds
6.3
15
4.3
Epic · grid
120
6
20 nodes · 67 armies
96
11 rounds
9.4
24
4.2
Epic · organic
120
6
20 nodes · 67 armies
96
11 rounds
10.2
17
4.0
Bot-only games simulated with this page’s engine: 200 games per Classic and Large row, 60 per Epic row. Game length is the median. Mop-up rounds counts from the winner first holding half the board to the win.
Game length barely moves. Income comes from your largest connected group, so it grows with the map. A 120-node game runs about 11 rounds against 9 on Classic. Your turn is what grows: bots make about 3 attacks per turn on Classic and 10 on Epic, and you would too.
Big grids breed giant stacks. On the 60-node grid, stacks reached 54 and a single battle ran to 150 coin flips. Battle animation has to compress long fights; the lab caps each one near a second.
Organic maps fix most of that. Planar links keep stacks under about 17, fronts easier to read and chokepoints more varied. They also look far better at scale.
The endgame drags. Going from half the board to 80% takes about 4 rounds, and nearly 9 on large grids. An auto-sweep that plays out a won position, or an optional two-thirds win line, would cut the mop-up.
More factions change the strategy. Bots only attack strictly weaker targets and choose deterministically. With six or more of them there is more bot-on-bot attrition to exploit, and their opening attacks each turn can be predicted exactly.
To make big maps comfortable to play, the remake needs pan and zoom with a minimap, chain attacks (the moved stack stays selected, as in the lab) plus drag-a-path to queue several attacks, fast bot playback with a per-turn summary, and territory shading so the fronts read at a glance. Atlas, Cathedral and Bauhaus show three takes on that shading.
Feature ideas
Beyond the visual overhaul
Replays and levels
Every map is a number. Replay any level, play a code a friend sends, or take on the daily map.
Full replays: the map number plus your moves rebuilds a whole game. Scrub a timeline and rewatch the bots’ turns.
Practice from any turn: branch off a replay and try another move, kept out of your stats.
A level ladder of hand-picked maps ordered by difficulty, measured by how often a strong AI wins them.
Stats per map size and layout: win rate, streaks, fastest win.
Play
Capture odds on hover, from the exact battle maths. Off by default for purists.
Threat preview: because bots pick targets deterministically, the game can mark which of your nodes each bot will hit first.
Coach: a tree search in a background worker suggests moves and grades your game afterwards. Max’s version of this wins about 94% of games.
Duplicate challenge: you and the AI play the same map; compare results.
New map shapes: archipelagos joined by bridges, rings, mirrored maps for fairness, 4–8 factions.
Feel
Switch art style mid-game without touching the board.
A sound set per style, synthesised in the browser: coin-flip ticks, capture chords, reinforcement swells. Haptics on phones.
Turn banners and a round summary (“Blue took 3 of your nodes”).
Victory screen that replays the decisive captures.
Auto-sweep once a win is certain, so the last rounds take seconds.
Build plan
A web app, rendered on the GPU
Recommendation: TypeScript, built with Vite and rendered with PixiJS on WebGL (WebGPU where available), shipped as an installable web app. It runs on your phone and desktop, works offline after the first visit, and needs no app store. If you later want native builds, the same code wraps in Tauri for desktop or Capacitor for iOS and Android.
Rules · source of truth
Rules engine
Plain TypeScript with no DOM and a seeded random generator. Takes moves, returns events: each coin flip of a battle, captures, repels, reinforcements, eliminations, victory. Unit-tested against the exact odds and the deal’s invariants. The engine in this lab already has this shape.
Events → timeline
Director
Plays events on a timeline with speed control and skip. The rules never wait on animation, so replays, fast-forward and rewatching a bot turn come almost for free.
Timeline → pixels
Style renderer
One module per art style: palette, fonts, node and link drawing, territory, effects and sounds. Pixi brings batched sprites, bloom and displacement filters and custom shaders; territory moves into a shader that computes each region per pixel.
Off the main thread
Bots and coach
A Web Worker runs bot turns on big maps and the optional tree-search coach, so the board never stutters.
On the device
Saves and replays
IndexedDB holds saves, stats and replays. A replay is tiny: rules version, map number, settings and the list of moves.
Around the board
Shell
Menus, level ladder, settings and the replay scrubber, in Svelte or Preact. Kept small and separate from the canvas.
Order of work
Port the engine to TypeScript with tests; tune the big-map presets in headless simulation.
Pixi renderer skeleton: camera, input, event timeline and one style end to end.
Bring your two favourite styles to production quality, with sound.
Game shell: menus, map numbers, level ladder, saves and stats.
Replay viewer and practice branching.
Big-map tools: organic and island layouts, path attacks, auto-sweep, minimap.
Assists (threat preview, coach), then a performance pass on phones and the install prompt.
Why not Godot or Unity? Either would work, but their web builds weigh 10–40 MB, start slowly on phones and make menu-heavy UI awkward. This is a 2D network game with a lot of interface; the browser stack is lighter and quicker to iterate on. Godot only wins if you want a native-first 3D version.
On sources: Max Bittker’s repository has no licence file, so the remake should not copy its code. This engine was written from the rules his notes describe, and game rules themselves are not copyrightable. Network Wars is Jim Rutt’s game; a personal remake is fine, but don’t publish it under that name.