What I learned developing my first video game with Construct

Source: www.scirra.com

I was recommended Construct about a year ago by a fellow programmer. He assured me that I, as a Game Designer without an extensive programming knowledge, would be capable of using it to build my own prototypes and indie projects by myself.

After further research I discovered the engine had actually been around for years, so I decided to get the free demo and start learning how to use it while developing a small indie project I could add to my portfolio, a browser-based project Lost Stuff. And last month I finally released my project!

It’s been a long way since I started, but I’ve learned a lot. If you’re thinking about learning how to work with this engine, or if you already are and are looking for some tips, I  hope you enjoy my review.

Cool things about Construct 2

So many hours staring at this interface…

  • You don’t need programming knowledge to finish a project.
  • The way to preview your work is quick and clean.
  • Exports to many platforms with one click.
  • The work space is flexible and adaptable to one’s needs.
  • The license is a one time purchase.
  • It’s stable. In my case, it never crashed, never lost the progress, everything worked well.

Other things that could be improved in Construct 2:

  • No 3D graphics support.
  • The debugger tool. My biggest complain is, maybe, that all the objects of the project are listed all the time on the inspector window, and it can be difficult to spot the one you want to inspect on the current layout.
  • Once my project was finished and I was more focused on performance, I wanted to get rid of all the object instances I wasn’t actually using, but couldn’t find a way to find them straight away. It would be great to get a list of all the instance appearances of an object at any given moment.

Also, learning things by oneself, of course, has its risks. I’ve found myself alone in the dark many times while developing this game. Construct manuals and forums helped me a lot to get myself introduced in the basic use, but if I had to figure out ways to implement a more developed logic, even if it was connected to typical video games features, I always got lost and had to finally come across my own solution by a bit of a brute force process.

My game! Lost Stuff

.

Play on an external window>> http://nadiaorenes.es/lost_stuff/

Lost Stuff is an interactive experience based on the string of pearls model consisting on cut scenes that develop the story and in between the hidden object gameplay layouts.

Which actually leads me to one of the best parts of using this engine: it’s flexible and easily accessible in a way you can develop your own project with your own rules. You don’t need to stick to any template or library, just start from scratch and do things your way.

If you are interested in experimentation this gives you freedom to surprise the player with an unusual mix of genres and art styles. And surprising people is what I love!

What I learned!

This is based on my particular way of approaching a development with Construct, with my current skill level and to suit the needs of the projects I usually work on (story-driven small indie games).

This means there might be other ways, much more if you count on programming knowledge. But I still think you might get some inspiring tips from this article, specially if you are a beginner.

So here I go with some tips you might find useful when working with Construct 2!

1) Variables are so cool! But use them carefully.

Variables everywhere. 0_0

As soon as I discovered variables and how flexible they are, I started using them as the base of solutions to different problems:

  1. To trigger dialogues or story beats during gameplay.
  2. To settle the conditions to be met for win states.
  3. To unlock chapters shortcuts as the player progresses.
  4. To save the game progress.

Variables are so nice it’s too easy to get carried away and start overusing them. But you need to be consistent in the way you’re using them, even more if you think you’ll go back to work on your project through a long period of time.

If you want to keep everything under control, I told myself at some point, you should stop creating variables as a reflex reaction. First, ask yourself if you could get the same behavior in other way, which will lead you to explore all the other tools Construct has to offer.

To sum it up, you better define your own variables logic and apply a descriptive nomenclature to it, in a way that you can use it intuitively later on.

Also, take into account what values your variables are holding at any certain point in the game flow (start of layout, end of layout, load complete, etc.). You might need to restart them at the beginning of each layout to avoid unwanted behaviors, specially if the player is given the choice to replay the scenes:

Finally, a small piece of advice: set a variable to a fix value instead of adding up numbers to the value whenever you can. Otherwise, take into account that the player might not always perform interactions the way you expect him to.

For example, if you trigger an action once a variable has reached a specific numeric value but the action is triggered with a delay (because there’s an animation that takes time to complete), take into account that the player might keep on performing that action on that short delay (for whatever random reason), which would keep on changing that variable value.

2) Comment, comment, comment!

This might come out as superfluous advice for some developers, but commenting in Construct is quick and easy, so don’t overlook its advantages.

Commenting is useful, specially when you’re your working with someone else, or if you’re trying to figure out how to do stuff and you keep on trying and discarding methods.

3) Group it on!

I got to discover the possible uses of this feature pretty late into the development, but from that moment on I started organizing my event sheets more efficiently.

Groups are just that, sets of events you itemize in one bundle into the editor. The trick is they are more easily manageable, and you can name them and comment them to fit your criteria. They also make it easier to copy and paste many events while keeping everything under control.

Besides, there’s some magic you can do with this. There’s a condition type you might use to deactivate groups of events, which might come handy if there’s a point where you want to change the game estate, for example, on the options screen.

4) Divide to rule

When I started working on my project, I used to create one event sheet for every layout sheet, but as the development progressed further on and I started implementing general features or screens, I started thinking about even sheets on a different way.

The thing is you can add as many event sheets as you want to each layout, which means that you don’t need to duplicate tasks for every layout event sheet if they all share common features. For example, if you create just one event sheet with all the logic implied in the pause menu and then you link it to each layout, you won’t have to update several event sheets every time you change something.

5) Size matters?

If you’re planning to produce a considerable amount of sprites for your game, it’s better that you apply some good practices having to do with image optimization:

-Add tile grounds when possible. There’s even a special object type for grounds built by repeated contiguous sprites:

-Adjust quality with the image editor. Once you’ve added an image to a Sprite object type, you can resize it and adjust its quality until you get an acceptable result.

-Upload animations frames on sprite sheets. Bundle your individual frames with some sprite sheet generator, and then upload them using the ‘Import frames from stripe strip frames’ option. Construct will add the frames individually so that you can handle them properly, but the image size will be much smaller.

6) Plan general features early on

Even if it’s really simple, a pause menu can be a real pain in the arse to implement if you don’t think about it early on!

When I started to develop Lost Stuff I thought I’d just build a simple prototype, but as I moved forward and started getting familiar with the tool, I went further and further, until I realized I was aiming at a final product.

Thinking about how to implement a pause menu too late into the development brought me more than one headache, because it’s something that affects pretty much all the layouts of the game. Besides, since it necessarily implies that everything happening on the game needs to be paused, I had to review variables and event tags in order to control them.

7) Don’t be afraid of game juice!

Working on your own projects is cool, even if the scope is reduced. Not until I playtested Lost Stuff did I understand to what extend are ‘superfluous’ details important. Most of the work I had done was to design and implement the main skeleton of the game, but there were some times where I just decided to go one step beyond, and added apparently useless details, some of which I knew might remain unseen for most players.

The truth is many of those details were the first thing people praised when they were giving me feedback about the game. Construct might be a more simple than other game engines, but it has many flexible features you can help to make your game feel more responsive and interactive.

-Particle generator! I used to hand-drawn my particles before I realized the Particles object type in Construct is actually easy to use. 

-Object visual effects. You can even add preset visual effects to a certain object and play around with their variables to adjust them to your taste:

-Native animations. It might take a while to get used to the system, but there’s a group of Construct events you can use to move stuff around. You can check a small experiment I did over here: http://nadiaorenes.es/b-day/  

Even if you implement them as the final layer in the development process, it’s good to explore these early on and experiment with them from time to time. It can also be a good mind relief to combine this visual work with tougher tasks like developing the logic behind events.

Wrapping up!

Lost Stuff is just a small story-driven project I developed to get in contact with this game engine, but there are lots of more complex and more interesting games out there: https://www.scirra.com/arcade/popular-addicting-games 

Construct is a solid and easy to use game engine if you want to build 2-D prototypes or simple interactive experiences that work well on devices and web.

I’m looking forward to the updates the third version will bring.

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.