Post-Mortem: Match-3 Tutorial Series

The final article on the site

The day has finally come, after months of work I have officially published the last article in my series about building a Match-3 game in Construct 2. Having finished the series a few weeks ago I’ve now had some time to consider the series from more of an outsider’s perspective and I thought this would be a good place to share my thoughts on it. You can play the final version of the game here and I’ll be including links to all the articles I wrote at the end of the series, but for now, continue reading for an in-depth look at how long it took me to make this series, and what I’ve come away with.

So first let’s look at some basic stats. This was one of the first projects I did with Construct 2, so at the beginning there was a bit of a learning curve. With that in mind, the game and the articles together took me about 4.5 months to complete. I started the game a little bit before GDC back in March, and after GDC was over and I had finished writing my post-GDC articles, I started working on this as my primary project during my free-time. During this period I probably worked on the articles or the game itself 10-15 hours per week, and about half my time on the project overall was split pretty evelny down the middle for time spent on the game, and time on the tutorials.

When I originally started the project I set out to do a 4-5 article series on how to make a Match-3 game, but because of the complexity of many of the topics, and the amount of material the series covered, my editor and I settled on a total of 8 parts. The actual writing process for the series accounts for two of the four months of development. During these two months I was writing roughly an article a week and was submitting them to my editor an average of three days before they would be published. The articles each averaged around 2,500 words, with a few of the later ones coming out a bit longer than that.

So what did I actually learn from writing these articles?

Using Construct 2

C2Layout

The most obvious thing I learned was how to use Construct 2, and how to make a Match-3 game on my own. Before this series I had never worked with Construct 2 before, so even though I had worked with similar systems, there was definitely a lot for me to understand about Construct 2 specifically. On top of that, while I had worked on my indie game Chromathud prior to making this game, I had never made a Match-3 game from scratch, and I had also never made one entirely on my own. When working on Chromathud I was primarily the graphics and QA guy, and only rarely touched the code. Despite that, there were a few instances where I worked with Brendan, my co-designer on Chromathud, to try and figure out how different things should be built. This experience thinking through the algorithms or processes needed to execute some of the ideas helped a lot when I was developing this game.

The Importance of Play-testing

Playtesting

The next thing I gained was a deeper understanding of the importance of play-testing. At the very beginning of the series there were a few small bugs in the original game that I hadn’t noticed, and because I hadn’t let enough testers other than myself and my editor play the game in advance, I didn’t find the bugs as soon as I could have. On top of that. I also found that the way I built the game originally was less-than-perfect and made many of the systems hard to explain. This forced me to re-design and re-build many of the systems while I was writing the articles so that the systems could be understood more easily by the reader. Since I was re-developing the game as I was writing the series, it was not uncommon for me to finish a new version of one of the systems and then find a bug in the system while writing a later article. In the end this helped the articles somewhat because it forced me to cover a larger variety of topics each week, and meant that every article ended up being packed with much more content than I originally planned. This situation also gave me more time to discuss each system over the course of the series, and really explain why every aspect of the system existed. On the other hand though, it does make the series as a whole seem poorly organized since some systems are being developed throughout the entire series but are randomly missing from a few articles, whereas others are integrated and done in a single article and never get mentioned again. So, while I did understand play-testing to some degree before I wrote this series, I definitely got a crash-course in exactly how much it can impact a project while working on this.

Paying Attention to Feedback

Feedback

The final thing I learned was the importance of paying attention to feedback as it is being given. While editing the seventh article I was forced to look back through the series at some of the earlier articles and I ended up seeing a comment that had been made on the second article very shortly after that article had been published. The comment was about an error that readers were encountering because one of the lines of code that I posted was missing a parenthesis. In the comment section another reader had attempted to answer the question the previous readers had, but because he didn’t really understand the reason for the problem he ended up posting a “solution” which would actually cause more problems in later articles if you didn’t account correctly for the change you made. After seeing this post I immediately responded to all of the commenters who were having issues and gave them the correct solutions and even explained to the commenter who tried to be helpful what the issue with his solution would be. Thankfully all of the commenters involved were just happy to have an answer and seemed happy to continue along with the series, but it wouldn’t surprise me to learn at least a few readers stopped following the articles because of this issue or another it could have caused.

Closing Thoughts

This project was overall a great learning experience for me. Before this point I had never really completed a full project on my own, so seeing everything come together was a lot of fun and incredibly rewarding. As I continue writing for GameDevTuts+ I will definitely keep many of these lessons in mind, and as I move forward and start considering what other series or articles I could write, it will be great to have this experience to draw from. While this wasn’t a true game development experience since a large motivation to work on this game came from writing the articles, it was still a lot of fun and should be a good inspiration for my future game projects.

If you want to read any of the articles you can find all the links below, or just head over to GameDev Tuts+, and browse many other great articles there.

Part 1 – The Basics

Part 2 – Animations and Block Swapping

Part 3 – Match Detection

Part 4 – Improved Matching and Gravity

Part 5 – More Swapping, More Matching, and More Points

Part 6 – Block Movement

Part 7 – Quick Fixes, and Eliminating Pre-Made Matches

Part 8 – Chaining and Game Overs

 

Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>