I just wrote about one particular element of Persistence that I wasn’t quite happy with.
With a little more testing, I decided to remove that part of the game and make it simpler to understand.
I just changed the “color war” modifier so that colour changing is twice as effective as it was and now there is no confusion about having to keep grabbing even once the whole block is on your side. It makes the game slightly easier to play, but much easier to understand.
Sometimes when you make something you become attached to a way it was, and attached to the original idea you had about a cool feature. When that feature doesn’t work as well as intended it can be hard to give it up. In this case I managed to.
There is one specific aspect of Persistence that I’m a little “hmmm” about still.
In the game, you capture the blocks, but the countdown to win the game doesn’t appear until all the captured blocks are fully red. To make a block fully red you have to “grab” it on passing flush when it is already fully on your side. Each “grab” at this point will make it a little bit brighter until it is the brightest red. When all captured blocks are the brightest red, the countdown appears.
I’m worried that this mechanic isn’t obvious (it’s not) and causes players to stumble when they’ve captured all the blocks and think “well what do I do next?”.
However, I really like the idea that the player has to do something with the blocks once captured – that it isn’t enough just to capture them, they have to be brightened and then held for the duration of the timer.
So I’m keeping it how it is, and hopefully some of those who gets stuck will read this and learn what they are supposed to do.
I finally finished making a game I’d been working at on and off for a while. It’s called Persistence and I don’t want to give an explanation since it’s designed to be played without introduction.
Click the image to play:
As usual, I learned a lot along the way, and I feel like I’m getting to a comfortable point where I don’t need to do a detailed code analysis every time since I can re-read my stuff and understand how it works much more easily than I used to.
I’m increasingly finding that solutions which required thinking quite hard at the time (and I was worried would be incomprehensible in refactoring) are actually much easier to understand re-reading the code afterwards. It happens a lot, and I’m only really just getting used to it. This is a great effect, as it gives me more confidence to plough ahead with a solution even if it seems complex at the time, because I can have some faith that when I look over it the whole thing will make good sense. With one caveat: only if the code works in the first place!