This week's blog post is going to be a little different because…
It's been exactly one year since I started on this Construct 3 adventure!
A whole year. I can't quite believe it to be honest! One thing is for certain though, I've learned a heck of a lot, and I don't think I can call myself a Construct beginner anymore!
If you've been following this blog, you'll know that I came into this with zero experience in programming or coding. Despite being at Scirra for about three years, I'd never really delved into Construct beyond doing a couple of beginner tutorials. What better way to learn than by building a ridiculously ambitious game right?
Building a Pokemon style game has been something I've always wanted to do and it seemed like the perfect passion project to learn the ropes in Construct. Granted it was a probably (definitely) too ambitious for a beginner to start with, but it's not turned out badly. In fact, it's given me the opportunity to learn some things in Construct that usually would have made me run a mile!
Within a few weeks of starting the Definitely Not Pokemon project, I'd published my first tutorial looking at a method for transitioning between layouts. It uses two sets of sprites that act as senders and receivers – so when the player steps on one, it gets sent to the corresponding receiver in the new layout. Looking at it, it probably needs a bit of a refactor (you're going to pick up on a theme here) but it's still pretty good for someone with only a small amount of experience in Construct. Okay, so I had help from the lovely Nepeo. But still!
Next up was the NPCs – these were an absolute pain to code and they're still not perfect, but I'm still proud of the state machine style system that exists in the game. There are six different types of NPC (technically twelve if you include the ones that can battle) each with their own specific movement code. If you look at the tutorials I wrote to go with these, you'll see the code is big, ugly and very cumbersome. In my current game file however, this has been shrunk considerable using families and instance variables – I would thoroughly recommend getting to grips with families, it can really help condense your events. In fact, you could have a stab at refactoring the example projects I created – they could do with it!
As well as movement, the NPCs also needed a way of spitting and engaging the player. That's where the Line of Sight behavior came in handy. It took a little bit of working out between origin points and instance variables, but it works well. An NPC casts a ray in whichever direction it's facing and if the player crosses in front of them, it triggers a 'battle' event.
Talking of 'battle' events, Advanced Random was another feature this game has encouraged me to learn about. Usually when talking about Advanced Random, people think of noise generation, but it also has a few other functions, like Probability Tables. A probability table allows you to generate weighted random numbers which for this game makes it perfect for random encounters! Wander through the grass, generate a random number every time the player steps on a tile and if it equals a certain value, summon a poke- I mean an enemy. Handy!
The most recent mechanic added to the game is by far the most complicated and my goodness took a lot of learning on my part. Up to this point, everything had been about learning Construct's system which was enough of an adventure. But putting dialogue into the game was going to take understanding some of the more
scary advanced features of Construct. So, I started to look at other examples of dialogue systems, using XML, variables and arrays.
Eventually, thanks to suggestions from the community and my Scirra colleagues, I started looking at JSON. Lots of reading on W3Schools and several experimental projects later, I had a vague understanding of JSON as a language and how to potentially use it in Construct.
A long way from quivering at the thought of using loops and functions!
Fast forward to April 2020 and there's now a course of tutorials covering dialogue systems, including using JSON to create branching dialogue. I never thought I'd be able to create something like that, but Construct enabled me to do it!
There's still tons more work to be done on this game idea, including the inventory (which is almost done in standalone form) and a turn-based battle system. But thanks to Construct, I feel like I can actually do it. I still have a lot more learning to do, but it's incredible what can be done with this program when you're starting from scratch.
A couple of things I will say though. Taking the time to plan out your project, no matter how big, is always worthwhile. I have two notepads I've been using for this – one to write out how events might work, which mechanics should be implemented where etc. And a squared one to sketch out layout designs, really handy for a tile-based game!
Also, sticking with the planning lines, bear in mind that it's incredibly easy to underestimate how long a project is going to take. Between feature creep and actually figuring out how something works, something that you thought might take a day or two can easily run into the weeks. Especially when you consider refactoring – a necessary evil!
Finally, remember to take time for yourself. If you keep grinding away at a project over and over it can quickly become a chore rather than something you enjoy. If you find yourself hitting a wall, take a step back, look at something else, and come back to the problem later. A fresh mind is better to tackle a problem!
Anyway, happy Construct anniversary to me and all that. Here's hoping I can keep learning new things and bringing you guys useful resources!