u/LionAndOtterStudios

Hey! We’re two developers making All Hands, a horde tower-defence roguelite where each run is shaped by the turrets you unlock, upgrade and build around.

We already have 38 turret types, so instead of choosing #39 ourselves, we’re letting Reddit design it.

The suggestion can be a complete concept, with mechanics, appearance and upgrade ideas, or something as simple as “a turret that shoots attack ferrets.”

We’ll handle the balancing and implementation.

We’d especially love an idea that creates an interesting new build or decision, rather than simply dealing more damage.

I'll engage with comments on this post, but suggestions and votes only count on the original competition post:

https://www.reddit.com/user/LionAndOtterStudios/comments/1vpj7i0/top_comment_gets_their_turret_design_implemented/

Hi, we're Lion & Otter Studios, a team of two mates from Melbourne, Australia, working on our first ever game, All Hands: (https://store.steampowered.com/app/4867340/All_Hands/)

We believe the best games are made by involving their community and incorporating their feedback from the ground up, so we're running a silly competition on this very post.

The most upvoted eligible top level comment as of 12pm UTC on 25/08/2026 will get their suggestion implemented in our game, before the demo goes live!

But, of course, there's some conditions:

• Nothing NSFW, inappropriate or offensive, keep it rated "G"
• It's subject to our balancing, e.g. "a turret that kills everything every millisecond" won't be implemented as-is
• If it's impossible to implement, we'll try to implement the closest concept we can, e.g. "a turret that turns the map into a black hole" isn't possible, but a turret that shoots a gravity well would be
• If it's copyrighted, we'll have to change it to be distinct
• If the winner is very similar to one of the 38 turrets we already have, we'll try to work out modifications
• You can design as much or as little as you want. You can name it, describe the look, suggest the fire rate, or you can just leave it at "turret that shoots attack ferrets" and we'll fill in the rest

So, with that out of the way, what turret are we missing?

We'll announce the winner (and the upcoming demo) on socials and Steam. Follow along with the journey:

Wishlist:
https://store.steampowered.com/app/4867340/All_Hands/

Various socials:
https://www.tiktok.com/@lionandotter
https://x.com/lionandotter
https://bsky.app/profile/lionandotter.bsky.social
https://www.instagram.com/lionandotterstudios
https://www.youtube.com/@lionandotter/shorts

We're looking forward to what you can come up with.
Thanks for participating!

We're two mates making a tower defense game in Godot, with a focus on a massive entity count.

The first hurdle was the zombies (or "customers" using in-game terms). I wrestled with getting them to stop walking through each other, and they took that lesson to heart. They started forming polite, orderly queues.

No, after you.

This was the first attempt at crowd avoidance. Every zombie looked a short way ahead, and if there was someone in the way, it hung back. Perfectly sensible on its own. With a thousand of them it meant every zombie waiting for the one in front, all the way down the line, and the horde dripped through the gap one at a time.

// lookAhead = 1.5 world units, ForwardConeCos = 0.5 (a ~60° cone straight ahead)
// Is this neighbour actually in front of me?
if ((dx * fx + dz * fz) / d <= ForwardConeCos) continue;   // no — ignore it
// It is. Hang back, but only if I'm not in ITS cone too, otherwise two zombies
// walking straight at each other would both stop and neither would ever move again.
if (iInJCone <= ForwardConeCos) return true;               // yield

Now, obviously, this approach wasn't working. Out of 200 zombies, only about a third ever got through.

It turns out this is a real, well-studied phenomenon: crowds arching and clogging at a bottleneck, the same way grain jams in a hopper. [Helbing, Farkas & Vicsek, *Simulating dynamical features of escape panic*, Nature 2000](https://arxiv.org/abs/cond-mat/0009448) is the classic paper on it, and it's also where "faster is slower" comes from.

So, back to the drawing board.

In describing how we wanted the horde to look, we talked about pulling and pushing, pressing and compressing to simulate a horde moving like a fluid. So that's what we implemented, a fluid sim.

// Count the zombies in every cell of the map. Pressure climbs quadratically
// once a cell is busier than the threshold.
pressure = max(0, count − lowThreshold)²
// Every zombie's personal space shrinks as its own cell fills up.
scale  = 1 − alpha × (density / maxDensity)   // clamped to 0..1
if scale < floor: scale = floor
bubble = baseSpacing × scale

Each entity (or zombie) has a kind of "personal space bubble" which can exert a small amount of pressure outward on other zombies, but the zombies behind push the zombies in front, pushing them into each other's personal space, and causing them to fill out the available space in the direction of the flow.

The blue colour really adds to the fluid sim.

Eureka! There's our zombie horde. They squished, they blobbed, and they flowed. Buuuut... there was a small problem. The frame rate. I'll save you from watching a 3fps clip and just tell you that we struggled to get the entity count into 4 digits.

The performance gain road was long. We used Dijkstra's flow field algorithm for pathfinding, a spatial hash to limit the amount of work the fluid sim had to do, and GPU caching to speed up the rendering. A de-penetration algorithm serves to floor the zombie horde squish to prevent them compressing into a zombie black hole.

// Flow field: one Dijkstra pass (Dial's bucket variant) from the goal, reused by every zombie.
// Spatial hash: a flat counting-sort grid, not a dictionary of lists — no per-query allocation.
// MultiMesh: 11,000 zombies drawn as instances, not 11,000 scene nodes.
// De-penetration: separate any overlapping pair to the tighter of their two bubbles.
// This is the floor that stops the crowd collapsing into a singular point.
pairSpacing = min(bubble[i], bubble[j]);

How it looks today

All of these elements came together to land on our current day zombie horde. A performant 5 digit entity count that flows cleanly through gaps, crevices and around obstacles!