The Spiral model for game development is a simple and elegant technique which is usually used to develop game efficiently. Inexperienced game developers tend to design a game with a lot of features and then start to implement all of them without have any order of priority. Is always a good practice to define which features should be developed first and which should be developed later.
Let’s see which are the best techniques used to develop software and which are the best for the video game development
This is a model called Waterfall:
This model can lead to problems. For example, what if you realize that some features that you’ve implemented doesn’t work as expected in the post production phase? Well you can go back to the Design phase to redesign that feature that didn’t work very well and then adjust the code to fit that new feature, but do changes to the software that you’ve already wrote it’s not something easy and sometimes if the changes are too big, it’s better to redo the project from scratch. Because of this, the waterfall model it’s good and efficient only for very small project. To avoid these situations, we can use a development technique called the spiral model:
The spiral model
The spiral model in action:
As you can see, this model allow flexibility and iterativity into the development process of the videogame. The first step of the spiral model cycle it’s the Design phase:
Design: Here you define the feature to develop in the next cycle.
Implement: Here it’s where you develop the features that you decide in the Design phase.
Playtest: Here it’s where you make sure that what you’ve made it’s fun for the player.
Evaluate: Final thoughts about what you’ve done right and wrong during the past cycle, forming a new set of observation and then go back to the first step.
This process has a lot of advantages:
- Keep the risks as low as possible.
- Start with the core features.
- Get a prototype quickly.
- You can use it with scrum.
- Allow fast changes
Keep the risks as low as possible:
If you discover that something planned isn’t working as expected on the design phase, you can easily change it on the next cycle.
Start with the core features:
The firsts cycles of the you game development process, will be dedicated to developing the core features of the game. This will allow you the discover as soon as possible if something is wrong with the core game mechanics of your game.
Get a prototype quickly:
The main goal when you start to develop your next game, it’s to obtain a playable prototype as soon as possible. When you have decided the core features, you’ll spend the first iterations to develop them. At the end of the first cycle, you’ll end up with a playable prototype that you can use to evaluate the core of your game and eventually, if there are some changes to do, you can do it on the next cycles.
This cycle show you how to obtain a prototype as fast as you can, and each cycle will lead you to a new prototype with new features, this cycle will go on until you’ll have an operational prototype with alle the minimum valuable features.
You can use it with scrum:
The spiral model can be easily used along with the scrum technique. This can help to increase your productivity and efficiency in your development process. basically each sprint plan can be associated to a development cycle on the spiral model.
Allow fast changes:
Something went wrong into the past development cycle? Or you maybe just decide to change or add a new feature into your game? No problem, you can easily add those to the next development cycles.
The last cycles don’t allow to do bug changes:
Imagine the building of your game like the building of an house. Each cycle equivalent to the construction of a wall in the house building. As we can imagine, if we plan it’s to develop a 3 floors apartment, we can’t change our mind and build a skyscraper after we’ve already made half of the house, the same it’s for the software development.
So, thanks to the spiral model, the game can be easily changed and adjusted, especially into the first cycles, later on, when you have designed and developed all the cores features, will be more hard to make big changes, this end to a simple conclusion: spend more time to think carefully on the design phase, especially on the first development cycles, because those are the most import cycles of your game, those are the cycles where you decide the core features, these are like the foundation of on house, once they are build you can build the rest on top of it.
The spiral model is for sure one of the best technique that you can use to develop games. There are others techniques that you can use, but the spiral is for sure the best choice if you are new to the game development.