Pipe and network puzzles

What it does

A tile's mask is the sum of the edges it opens on, from UP, RIGHT, DOWN and LEFT, so a straight, a corner and a cross are just numbers. One board, createFlowGrid, holds either game, flat or with its edges wrapping round.

In the network puzzle, in the style of Netwalk, generateNet grows a random spanning tree over every cell from the server, records it, and turns each tile a random number of quarter turns, so every board is solvable by construction. A branching dial runs from one long winding line to a network that branches everywhere. After each rotate, connectivity says which cells are joined to the server, so the network can light up as it grows, and solveNet gives the turns back to the solution for hints and autoplay.

In the pipe-laying game, in the style of Pipe Mania, a seeded queue deals straights, corners and crosses. The player lays the next piece on an empty cell or over a pipe the water has not reached yet, at a cost. After a delay the water runs on the game clock, one pipe at a time, straight through crosses, until it spills at the first gap or finishes in a drain; the round is won if it filled enough pipes first. pipeStatus gives the water's cell, the edge it entered by and how far through it is, for drawing each pipe as it fills.

A run strings rounds into levels: each asks for more pipes, a shorter wait, faster water and more obstacles, up to a limit, with lives and a running total. A hint says where the piece in hand should go, and an autopilot plays a whole run for attract modes.

Features

• Edge-mask tiles — any tile is a set of up to four edges, with a flood that tests connection from a source.
• Solvable network boards — generated from a spanning tree and scrambled, with the solving turns kept.
• A branching dial — from one long winding route to a bushy network.
• Live connectivity — the cells joined to the server after every turn, and a solved test with no loose ends.
• Wrapped boards — edges that join across the border, for connection and for the water.
• A dealt pipe queue — weighted pieces with a preview, after any pieces you fix in advance.
• Timed water — a delay, a speed per pipe, a hurry button, crosses filled twice and drains to finish in.
• Scoring — points per pipe and per extra pipe, crossing and drain bonuses, and costs for replacements and dry pipes.
• A level ladder — target, delay, speed and obstacles that change each level until a limit, with lives.
• Hints and an autopilot — suggestPipe for the next piece, and pipeAutopilot to play a run.
• Authored rounds — a hook before each round to lock cells, set fixed pipes and choose the start or drain.

Good for

• Rotate-the-tiles network puzzles, in the style of Netwalk or Net, flat or wrapped.
• Pipe-laying games against the clock, in the style of Pipe Mania or Pipe Dream, with a dealt queue and a level ladder.
• Wiring and circuit puzzles, where a tile is a set of connections and the question is what reaches the source.
• Attract modes and demos, played by the autopilot.
• Minigames inside larger games, such as hacking a terminal or fixing a ship's plumbing.

Make it yours

The board takes its size, a seed and whether it wraps. A network board takes a branching value and a server position. A pipe round takes a start and exit, fixed queue pieces, the piece mix and weights, the preview length, the delay, the speed, the target, a drain and whether it is required, obstacles and the scoring. A run takes the board, lives (as many as you like, for endless retries), the first level, the ladder, the scoring, the pieces, the drain settings and the authored-round hook.

Two very different games: a wrapped nine-by-nine network puzzle with low branching, whose long winding routes make every turn matter; and a pipe-laying run on a ten-by-seven board with three lives and a drain every round, starting at 8 pipes after 15 seconds and climbing to 30 pipes at half a second each with 10 obstacles.

A quick look

A generated network board, turned and checked:

const net = game.netflow.createFlowGrid({ cols: 9, rows: 9, seed: 4, wrap: false });
net.generateNet({ branching: 0.4, source: { x: 4, y: 4 } });
net.rotate(2, 3);                         // a quarter turn clockwise
const { lit, litCount } = net.connectivity();   // joined to the server now
if (net.solved) win();
const turns = net.solveNet()!;            // turns back to the solution, for a hint

Works with

• deduce — for light-toggling and other deduction puzzles.
• levelgen — for maze generation in general.
• tween — to animate rotations and the water filling each pipe.

Good to know

• Network boards are trees, one route to every tile with no loops, and solveNet replays the recorded solution: it is not a solver for an authored board.
• There is no undo stack for the network puzzle; a turn is undone by turning back.
• The pipe game has no bonus or one-way pipes or reservoirs, and a replacement costs points, not time.
• The pipe hint is greedy: it looks at the piece in hand, not the queue, and can wall itself in.
• Drawing lines between pairs of dots is a different puzzle, and no pack covers it yet.