Smackshapes

Welcome to the devlog for my game Smackshapes. The game is part of the SwiftSmash Saga collection, which is all about games where you simultaneously reveal cards and must then be the first to smash (or just tap/pick) the “right card”.

This devlog will be very short! I know, that’s a rarity for me. I often promise that and always fail to keep it brief.

But this time I am certain, because the game is already done. In this devlog, I’ll quickly guide you through the process of making the game, why I made certain (interesting) decisions, and then give my thoughts about the final result.

What’s the idea?

Some time ago, I made Cookie Smasher. At the time, it was just an experiment and not planned to be a series.

When I finished that game, I had the usual thought: “The game is fine, but now I know how to do it better and simpler.”

I wrote down the general idea for Smackshapes (dubbed the “Kids Version” of Cookie Smasher back then). I saw that it would indeed be far simpler, and knew it would probably work. I was busy with other projects, however, so I dropped it for a year or so.

That version of the game was as follows.

Cards show colored shapes. (These don’t have to be the same: a card might show a red square and a green circle.)
Everyone plays a card at the same time. When revealed, you have to find the shape that appears the most (and smash a card with that shape)
If there’s a tie for that, you must pick the color that appears the most (and smash a card with that color)
If still a tie, smash any of the winning cards.
(And PERHAPS the game would add rules cards: these would have a different rule for finding the “winning card” than the usual one I described above. If anyone played one of these, their rule would take precedence.)

A fine idea, but not as streamlined as I’d like. This didn’t guarantee a single winning card. It did lead to many ties, which are hard to calculate for players (and not that interesting/fun). And the Rules cards would stop this from being a “Kids Version”, because it would require complicated text on the cards to explain each rule.

When I came back, the idea had simplified even further in my subconscious brain. It had come to this:

Cards only have one color and one shape. (For example, “2 red squares” or “3 green triangles”)
Moreover, the number of them is unique. (There is only one card with 3 green triangles, never more.)
Moreover, each card shows a ranking of all shapes. (This can be done with icons and without text.)
This allows simplifying the core rules.
- The card from the start player shows the ranking. (Example: Square > Triangle > Circle.)
- Tap the card with the highest-ranking shape.
- If tied, tap the card with the most of them.

This always leads to a single winning card, without any bias. (Cards with a high number—a lot of shapes—don’t necessarily win more often, because their shape might be on the low end of the random ranking.)

This also allows the game to function with only ~25 simple cards. They show no text, just basic shapes in basic colors.

In fact, you might notice that colors don’t matter now. I briefly considered removing colors entirely and just making this the final game, but I decided against it.

Those colored shapes are necessary to make the game look more vivid and, well, colorful.
These core rules are so simple that I really want to add an expansion that uses those colors and adds some spice.

This expansion, as expected, uses the colors.

My first thought was to bring back the old rule: “In case of a tie, tap the color that appears the most.” But, well, our game has no ties right now and I don’t see why I would mess with that.
After some brainstorming, I found the simplest rule that does have massive consequences to gameplay: “If all colors are the same (in a round), it inverts. You want to tap the lowest ranking shape and the lowest number.”

With that, the rules were a single page and the game worked well. Whatever people played, you will never immediately know the winning card, nor will it take you a minute to calculate.

Let’s make that

The code that generates the cards is nothing special.

It simply loops through all shapes + all numbers allowed, then creates one card for each combo. (The numbers are between 1–9. Some of them, however, are reserved for the expansion. Because those cards should be unique too!)
It assigns colors randomly, but fairly. (Some colors might appear more often than others, but the difference is never larger than 1 or 2.)
The expansion also adds an action to the cards. This is randomly picked from a list of templates (like “Ignore the color %color%”), where the thing between percentage signs is replaced by a randomly picked color when drawing the card.

Similarly, the visual design is nothing special. With Cookie Smasher, I entered a visual style for this series that is all about minimalism and giving cards a mostly solid (white) background. I won’t do this for all games, but for the absolute simplest of them all, it felt fitting to use the absolute simplest card design.

Below are my quick sketches and notes on the design.

The exact sizes and positions of things are never set in stone; I’ll finetune that when the generator is making the cards.

I used simple pencil brush strokes to mark some boxes. I used basic shapes, but with that pencil outline again to set them apart.

Then, in code,

I tint the shapes to represent the color of the card. (The original shapes are just white with a black outline, but with a simple effect I can make that any color. Because tinting always makes things darker, a black outline is preferred here—it will just stay black and keep the look consistent.)
I manually picked the positions of the cards where shapes can appear. For each card, it just randomly picks from that list and draws the shapes at those locations.
(When an action is present, it’s forbidden from picking positions low on the card, which are all past the halfway point of that list.)

I drew this one night, I implemented it two days later (when I finally could go back to using my laptop), and … well, nothing special to say.

My only “doubt” was the size of the ranking at the top. Shouldn’t it be larger? It’s such a crucial element to each round!

Then I tried it and realized that, no, this design is fine. That ranking only matters on the card played by the start player. While the shapes + colors of a card always matter. So those should still be most prominent and easy to read.

Moreover, different people might have different strategies—some check the ranking first, others count shapes/colors first and then look at the ranking, etcetera. For some the ranking has “highest priority”, for some “lowest”, and that’s great! Diversity in strategy is always good. I don’t want to ruin that by making the ranking so large you can’t help but start by seeing it.

This means the final material looks as follows.

Please remember I always compress my images quite heavily, to keep my (free) website fast and light. The real material is never as slightly pixelated/blurry as these screenshots. Pencil brush textures somehow always do horribly under compression.

Conclusion

That’s it!

The idea was basically a “fifth iteration” of Cookie Smasher, simplifying it every time, which gave it a solid base already. With some slight tweaking, and a simple and clear (textless) design, the game just works. And I stop there to prevent myself from overthinking or overcomplicating it.

The rules should be teachable to anyone and any group. It’s fast to play and anyone can win, but being the first to smash the right card is still hard to do every time. I think it nicely finds the balance between making players think oh that’s easy, but then turning out a little more challenging as they play.

As such, right now, this game is firmly in the spot of “simplest SwiftSmash game”, and I don’t see anything dislodging it.

Until the next devlog,

Pandaqi