Devlog 1: Capturing Creatures - A Week 1 Overview

A starting point

We’ve been working on this project for a while, but never really documented the process until recently.

So we decided to start from here.

Week 1. Not literally, but it helps to define a clear beginning and start being more intentional about the decisions we’re making.

Capture system

This week we focused almost entirely on the capture system.

The idea is simple: you draw loops around creatures until they get captured. It’s clearly inspired by Pokémon Ranger, so instead of guessing, we went back and played it again to understand what actually makes it feel good.

One of the first things we noticed is how forgiving the system is. When you draw a loop, the game doesn’t force you to restart from zero every time. The unused part of your line is preserved, which makes it much easier to draw the next loop and keep going.

That detail alone changes the experience quite a bit.

Another important aspect is how loops break. They break only when a creature steps over the line, but they only deal damage if it actually attacks. That distinction makes the system feel fair instead of punishing.

Right now, our implementation follows that structure, but it’s still missing a lot in terms of feel.

Damage and progression

Damage is currently tied to successful loops. Each loop adds progress to a capture bar, and once it fills up, the creature is captured.

What makes it interesting is that the progress slowly decays if you stop looping. This creates a soft pressure to stay consistent without forcing a strict pace.

We’re exploring ways to push this further, especially around rewarding good execution:

• consecutive loops increasing damage
• keeping the system simple while still giving it depth

Nothing is final yet, but it feels like the right direction.

Creature behavior

At the moment, creatures mostly move in semi-random ways. There’s no clear pattern, no anticipation, and no real communication of what they’re about to do.

This is one of the biggest gaps right now.

From analyzing Ranger, it’s clear that readability is key. Creatures don’t just move — they signal intent. That gives the player time to react and makes the system feel skill-based instead of random.

Right now, our version lacks that layer, so the next step is to move from randomness to something more intentional, introducing different animations, states, and anticipation for each creature.

Timer vs battery

Originally, the system used a timer.

It quickly became clear that it wasn’t working.

A fixed time limit made everything feel rushed, and outcomes depended too much on timing instead of player decisions. It also didn’t scale well — adding more creatures just increased chaos within the same time constraint.

Switching to a battery system changed that.

Instead of limiting time, we limit how much the player can act. The battery drains as you draw, which introduces a different kind of constraint.

The main difference is that the player can now:

• wait for better moments
• avoid bad situations
• play more deliberately instead of reacting constantly

It also opens more space for future systems like upgrades or abilities.

Map experiments

We also experimented with procedural maps using Perlin Noise.

We tried to push it quite a bit, adding smoothing and dithering to better match the pixel art style. From a technical standpoint, it worked.

But visually and in terms of control, it didn’t.

The result felt inconsistent — sometimes too empty, sometimes too dense, and rarely intentional. It might make sense in a game with more terrain variation, but for a mostly flat space, it didn’t fit what we needed.

A simpler approach

We ended up going with a much simpler solution.

Instead of generating maps, we built a large static canvas using sprites and then move the camera across it. It’s a controlled setup that still gives enough variation without losing visual consistency.

Right now, it’s just a static background, but the idea is to build on top of it:

• small animated elements (grass, flowers)
• subtle environmental movement
• more life without losing control

We also added bushes as spawn points for creatures. This introduces a small decision layer, where the player can choose how many creatures to engage with at once.

The bigger picture

All of this feeds into the actual game loop.

The idea is that players will:

• capture creatures
• store them (with limited capacity)
• place them on islands
• generate resources
• optimize their setup

Since it’s an incremental game, capturing should become easier over time. The focus is not on increasing difficulty, but on improving efficiency and scale.

Current state

Right now, the foundation is there.

The capture loop works, creatures move, and the interaction is functional. At the same time, there are still obvious gaps: no UI, no sound, and creature behavior is still quite simple.

The connection with the island system is also missing, so the full loop is not there yet.

Closing

This week was mostly about understanding the system rather than just building it.

Figuring out what makes it feel fair, what makes it frustrating, and where we need to push further.

There’s still a lot to iterate on, but the direction is much clearer now.

Next Steps

If you’re interested in the project, join us.

We’ll share a playable version as soon as it’s ready.

In the meantime, feedback on the capture system is always useful.