Nanobots

Cover
GIF
Level Generation Algorithm - (Click to play GIF)
Combat
Upgrade Screen
More combat
Even more combat!

-->> PLAY THE GAME HERE <<--

Inspiration

Nanobots are a big part of where medicine and technology could be headed: tiny machines sent into the body to find problems and fix them from the inside. We wanted to turn that idea into a fast arcade game. What would it feel like to be the nanobot, pushing through tissue and fighting off whatever doesn't belong there?

What it does

Nanobots is a top-down rogue-like shooter. You're a nanobot injected into a patient, and your job is to destroy every tumor in the area before the body's hostile invaders overwhelm you.

Every level is procedurally generated. Each run builds new cave-like tunnels and arenas inside the body, so no two levels play the same.
Tumors are your objective. An on-screen pointer guides you to the remaining tumors. Clear them all to finish the level.
Enemies fight back. Bacteria rush you and Viruses strafe and fire projectiles. Each level brings tougher waves, and enemy health scales up as you go deeper.
Upgrades. After each cleared level you pick one of several upgrades, and there are 17 in total, including:
- Stat boosts: damage, fire rate, move speed, projectile speed, max health, regen
- Static Charge: moving builds up charge, and stopping releases it as a shock around you
- Super Capacitor: you build bonus damage while holding fire, and shooting drains it
- Focus vs. Panic protocols: you choose between doing more damage at long range or at close range (you can't have both)
- Targeting Software: a targeting reticle marks random enemies so they take extra damage
- Objective upgrades like healing when you hit tumors or bonus damage after you hit one
Full game feel: pixel art, dynamic shadows, screen shake, sound effects, music, a pause menu, and full gamepad support.

How we built it

We built Nanobots in Godot 4 using GDScript.

Level generation: a step-based pipeline. It starts with a noise pass, then places arenas, carves tunnels between them, smooths the edges using cellular automata, and fills in isolated pockets. The result is drawn with a dual-grid tile-map system and a separate side-wall layer, which gives the walls a sense of depth.
Enemy AI: a small modular behavior system made of reusable pieces like move, wait, jump, strafe, line-of-sight check, cooldown, repeat, and spawn. Combining these let us build new enemy types quickly.
Waves: enemy waves are defined in a simple CSV file, so we could tune difficulty without touching code.
Combat: a component setup (hitbox/hurtbox, health, knockback, breakable) shared by the player, enemies, and tumors.
Upgrades: a pool system where each upgrade has its own script, levels, and description. Some upgrades are mutually exclusive.
Art and audio: all the pixel art was drawn by hand, including an animated player with a claw and tentacle segments. We also added sound events and background music.
We used Claude Code to help debug, clean up code, and speed up parts of the upgrade system and map generator.

Challenges we ran into

Scope was our biggest enemy. We had many more ideas than time, so we kept cutting and prioritizing to ship a complete game loop. Tile-maps were a real fight (we have a commit literally titled "i hate tile maps"). Getting the dual-grid walls, side walls, and roofs to line up with generated levels took many rounds. The UI also went through about nine redesigns before we were happy with it.

Accomplishments that we're proud of

The pixel art: the player, enemies, tumors, tiles, and a big batch of upgrade icons, all made during the hackathon.
The procedural level generation, which produces organic, body-like caves that feel different every run. It was pretty fun learning and applying cellular automata rules for the smoothing logic.
A full game loop: generate a level, fight, clear the tumors, pick an upgrade, go deeper.
Upgrade combos that change how you play, not just how big your numbers get.

GIF of Procedural generation algorithm How the procedural generation algorithm works:

Generate random noise and "arena" locations.
Clear radius around arenas.
Connect arenas together with tunnels.
Smooth out terrain using cellular automata. If a filled cell has <4 neighbors then the cell dies. If an empty cell has >4 neighbors then it gets filled in.
Fill in air gap in terrain using flood fill so there is only one cave system as all areas are accessible.

What we learned

We learned a lot about game development in Godot, especially procedural generation, tile-maps, and building modular systems like AI and upgrades that are easy to extend. We also learned how to work as a team under a time crunch: splitting up art, systems, and UI, resolving merge conflicts, and knowing when to cut a feature.