Cheery Chimp

Catching the fish is not the game. Getting them home is the game.

Fishing is a drop-line game played down a single column of water. You cast, the hook sinks, and while it sinks you steer it left and right. When you decide you have gone far enough you reel, and on the way back up the hook collects whatever it touches. Break the surface with your haul and it is banked. Hit a hazard on the way and you surface with nothing.

That last sentence is the design. Everything else serves it.

The descent is free

Going down costs you nothing. There is nothing to lose on the way down, because you are not carrying anything yet — you are just steering an empty hook through water, picking your line, deciding how deep to commit.

The moment you reel, the meaning of every object on screen inverts. A fish that was scenery becomes cargo. A drifting tire that was irrelevant becomes the thing that can take your whole trip away. The same column of water you just fell through unbothered is now a gauntlet, and it is longer the deeper you went.

This is the oldest structure in gambling and it works because it is honest: the reward for depth is better fish, and the price of depth is a longer trip back holding them. The game never has to tell you that you are being greedy. You feel it in your thumb somewhere around the point where the hook is full and the surface is a long way up.

It also means the decision that matters is one nobody prompts you for. There is no "cash out" button flashing at you. There is just a moment, different every drop, where you stop going down.

Four zones, and the one I had to go back and add

The water runs Freshwater, River Delta, Saltwater, Deep Sea, top to bottom — twenty-four species between them and a boss guarding each of the four.

It did not start that way. The first version had three zones: fresh at the top, salt below it, deep sea at the bottom, eighteen species and three bosses. The problem was the seam. Water above was fresh, water below was salt, and you crossed between them at a fixed depth with nothing to mark it but the fish changing. It read as two games stacked rather than one journey, because rivers do not become oceans at a line.

So the River Delta went in between them: brackish water with six species of its own — mullet, catfish, needlefish, gar, horseshoe crab, a brackish mussel — and its own boss, an alligator gar. Inserting a section into a finished progression is more work than adding one at the end, because every difficulty curve, every gear tier and every species rarity has to shuffle up to make room. It was worth it for one reason: the delta makes the change from fresh to salt a place you travel through rather than a boundary you cross.

The bosses escalate down the column in step with the water — a river sturgeon in the fresh, the alligator gar in the delta, a moray in the salt, and at the very bottom something called Hadal, named for the deepest layer of the ocean and drawn accordingly. The gar takes three passes to land, because a fish that big should not come up on one pull.

The hazards are litter

The things that can cost you a trip are a bottle, a tire and an old shoe.

That choice does more work than it looks like. A monster guarding the water would make the game about danger, and this is not a dangerous game — it is a patient one. Junk snagging your line is the ordinary indignity of actually fishing. It keeps the tone light while still being the thing that takes your haul, which is exactly the register a game wants when the punishment is total.

There is also the obvious second reading, which is that the things floating in the water ruining the fishing are the things people threw in it. The game does not say that anywhere. It does not need to.

Every fish faces right

A rule with no exceptions, enforced in the artwork rather than in the code: every sprite is drawn with its nose toward positive x.

The renderer flips them when they drift the other way, through a single CSS transform driven by one custom property, and rotates them nose-up when they are hanging on the line. One convention in the assets, one line in the renderer, and no per-fish orientation data anywhere.

The alternative — letting each sprite face whichever way it was drawn and recording the direction alongside it — is how you end up with a table of twenty-four booleans that somebody has to keep correct, and one fish swimming backwards for three weeks before anyone notices. The same discipline applies to the identifiers: one list of fish ids and one map of boss portraits, in one file, and everything else refers to those. If a sprite is missing, it is missing everywhere at once and loudly, instead of in one place quietly.

Time that does not depend on your phone

The simulation runs on a fixed timestep with an accumulator: real elapsed time goes into a bucket, and the physics steps in constant slices until the bucket is empty. A fast screen and a slow one see the same fish move the same way, which matters in a game where the difference between catching something and missing it is the width of a hook.

The wrinkle is what happens when a phone goes into a pocket. Switch tabs for two minutes and the next frame reports two minutes of elapsed time, which the accumulator would faithfully spend — simulating the whole gap at once, hanging the browser, and delivering you back to a drop that has already been resolved by hazards you never saw. So elapsed time is clamped: no single frame may be worth more than a quarter of a second. Come back after a long absence and you resume where you left off rather than arriving at a conclusion.

Asking the shell how tall it is

The game runs in a frame inside the site, under a header bar, and it needs to know how much of the screen is actually its own.

The wrong fix is the one I nearly used: subtract the header's height inside the game. That hard-codes a fact about the page into a thing that does not own the page, and every game would carry its own copy of that number, and all of them would be wrong the day the header changed.

Instead the game asks. It reads a header height from the shared bridge module if one is exported, and falls back to zero if not — a namespace import and a default, no error either way. A game that runs under a shell that does not advertise a height simply gets no offset and looks the same as before. The number lives in one place, on the side that owns the header, and the games read it.

On a phone the whole thing fills the visible viewport. On a desktop it does not: past a certain size the column stops growing and becomes a centred, height-capped panel with rounded corners against a dark background. A vertical fishing game stretched across a sixteen-by-nine monitor is a column of water two metres tall and three centimetres wide, which is neither playable nor dignified.

Two builds, one engine

There is a single-file version of the game — everything bundled into one HTML file, about forty kilobytes, no server, no modules to fetch.

The thing that makes it useful is that it is built from the real source, not maintained alongside it. The bundler is pointed at the same engine and the same renderer the site version uses, so the standalone cannot drift. A hand-maintained "demo version" is a second codebase that looks like a convenience, and it lies to you the first time you fix a bug in only one of them.

Underneath, the engine is a pure module that knows nothing about the screen and is proved by its own tests. On top of that there is a headless run through a simulated browser that drives a complete cast, reel and bank without a screen anywhere — which catches the specific class of bug that pure-engine tests never see, where the simulation is perfectly correct and the thing wiring it to the page is not.