Protector: The Game Boy Shooter Where Rescue Is the Hard Bit

Protector: The Game Boy Shooter Where the Rescue Is the Hard Part

Every Defender-style shooter has the same problem, and it isn't the shooting.

Pointing a ship at a thing and pressing fire is a solved problem. What isn't solved is the other half — the part where the enemies aren't trying to kill you, they're trying to take something away from you, and the only way to stop them is to fly directly into danger with your hands full.

That's the whole game in Protector, one of the homebrew titles we've built for the original Game Boy. And it understands something that a lot of Defender clones forget: the landers aren't the threat. The landers are the clock.

The worst thing on the screen

It starts simply enough. You're a ship, and there are humans standing on the ground. Landers come down, pick one up, and start climbing for the top of the screen.

Let one finish the trip and it stops being a lander. The pair becomes a fast, shooting mutant, and now you've got a problem that flies and shoots back. Lose every human and it's over — not because your ship died, but because there's nobody left to protect.

So the instinct is to shoot the landers on sight, which is the correct instinct and also the trap, because of what happens next.

Forty pixels

Shoot a lander while it's carrying a human and the human is dropped — from wherever the lander happened to be.

If it was low, the human survives the fall. If it was already high, the human is killed by it. Not by the enemy — by you. By your shot. There's a threshold in the code: less than 40 pixels and the human makes it; more and they don't.

That single number turns every lander into a maths problem you have to solve in the second and a half it takes to climb. Shoot too early and you've killed the person you were trying to save. Wait, and the mutant gets made and the person is gone anyway. There's a window, it moves, and it's on you to hit it.

It's a genuinely nasty piece of design, and it's the reason this game stays interesting past the point where most shooters of this vintage have shown you everything they've got.

Catching a human

Which is where the actual mechanic lives. You don't have to let the human fall at all — you can fly into them.

Catch a falling human and they ride under your hull. Then you have to do the hardest thing in the game, which is not die, because now you're carrying someone. Take them down to the deck and they walk away, safe, for 500 points — comfortably more than you'd get for a screen of enemies.

So the game keeps asking the same question in different shapes. Do I go for points, or do I go for the human? Can I make it across the screen with a passenger? Is that mutant between me and the drop-off point?

The smart bomb helps, at least. B clears the screen, and you get three per life — a genuine panic button for the moment you're carrying someone and the sky fills up.

The whole world, in a strip of dots

Along the bottom is a scanner, and it's more useful than it has any right to be. It shows the entire 1024-pixel world around you: large dots are enemies, small dots are humans, and you are the dot in the centre.

Once you can read it, you stop flying blind. You can see a lander committing to a descent on the far side of the map and decide whether you can make it in time — which is exactly the decision the game is built around. Best score is saved to the cartridge and shows on the title screen, so there's a number to beat.

It draws its own frame

Turn the Super Game Boy border on and there's "SAVE THE HUMANS" running along the edge of the frame, in a custom palette and border the game draws itself through SGB command packets.

What's nice is the care taken with the plain hardware: on a real DMG, everything SGB-related sits behind a version check, so the game is pixel-identical without it. No half-drawn border, no compromise. It just knows where it is.

Under the hood

It's C on GBDK-2020, written from scratch, no engine.

The interesting problem here is that the world is a 1024-pixel torus — fly off one side and you reappear on the other — but the Game Boy's hardware map is only 32 tiles wide. So one 15-tile terrain column is streamed in every 8 pixels the camera moves, which is the sort of thing that works beautifully right up until the seam between the two ends of the world, where collisions quietly go wrong.

The fix is a single function, torus_dx(), that returns the signed shortest distance between two x positions, so nothing breaks across the join. It's checked exhaustively against a brute-force calculation rather than trusted — which is the correct amount of paranoia for geometry you can't see.

The lander state machine and the rescue rules have no Game Boy dependencies at all, so they run as ordinary host unit tests without an emulator. And the HUD is drawn on the window layer at the bottom of the screen, which means it costs no scanline interrupt, with the scanner blips drawn as sprites over the top. The high score lives in five bytes of cartridge SRAM behind a checksum, written only when a run actually beats it.

How to play it

Click the screen to give the emulator keyboard focus. Arrows are the d-pad; X is A, Z is B, Enter is START, C is SELECT.

Left and right thrust with momentum, up and down move you vertically, and A fires — hold it for autofire so your thumb doesn't have to. The rescue has no button at all: fly into a falling human to catch them, descend to the deck to set them down. And Backspace is rewind, which is worth knowing before your first rescue goes badly.

Go save somebody

Protector is free in your browser, running on the hardware it was written for, with nothing to install.

Play it for the shooting if you like — but the game won't be about that for long. It'll be about whether you can get one more human home.

How many humans have you saved in a single run? We want numbers — and we want to know whether you shoot the lander or go for the catch.