Chapter 8. Break, Destroy, and Rebuild - the Art of Playtesting and Iteration
In this chapter, the reader will learn about methods of playtesting and iteration in order to improve their design. We will suggest ways to test, what to look for, and what to pay attention to during this stage. We will learn about these and a few other things along the way in the following sections:
To begin, Playtesting will describe the basics of developing your playtest, from types of playtesting to who you need to test your application.
Next, Methods of play testing - game time will explain how to go about your playtest and various things that need to be taken into account both before and after you have finished testing.
Now that our application has reached the final stages, After the game will cover what to do once you have finished playtesting and how to use the information as part of the iterative process.
After reflecting on the feedback from playtesting, Iteration will explain the iteration process and the...
This is one of the most important parts of your game design. In fact, you cannot expect to have a great game without it. Playtesting is not just about seeing if your game works, or if there are bugs; it is also about finding out what people really think about it before you put it out there for the world to see. In some cases, playtesting can be the difference between succeeding or failing epically. Consider this scenario: you have spent the last year, blood, sweat, and tears, even your soul, creating something fantastic. You probably think it's the best thing out there. Then, after you release it, you realize that only half the game was balanced, or worse, half interesting. At this stage, you are going to feel pretty down, but all this could have been avoided if you had taken the time to get some feedback. As humans, we don't necessarily like to hear our greatest loves being criticized, especially if we have committed so much of our lives to it. But the thing to keep in mind...
Methods of playtesting - game time!
Why are players playing your application? Ask them questions such as Why did you do that?, Do you understand the rules or is it confusing?, or Did you expect that to happen?. Getting feedback at these crucial moments can let you know whether the game is being played and understood as it should be. Of course, you need to keep in mind what you want information about, as the preceding questions are very general. This is a good place to begin, but as the testing develops you will want to ask more specific questions, such as Did you feel more motivated when you received a badge? or Is it tedious having to select from a large array of options?.
Observing how testers are playing
While testers are interacting with your game, observe how they are doing it, just like in the following screenshot. Do they engage in a particular way that is not intended? This may demonstrate that you have some glitches in your experience that could even be exploited. For example, if...
Asking playtesters directly about their experience with your game or application will give you a lot more detailed information about why certain elements were good, and others will not give you so much. For example, one tester may like the Leaderboards because it gave them a sense of achievement, and the other may like them because they enjoyed being better than everyone else. These two varying opinions are useful; if your intention was to encourage competition, then at least you know that to some extent, it's working.
Asking them to explain the game to you
| |
"If you can't explain it simply, you don't understand it well enough."
| |
| | --
Albert Einstein
|
The same can be said about your game. If players can't describe what your game is about, or what it is supposed to achieve in its simplest form, then it's not clear enough. This could be because the rules are ill-defined or that the objectives are not clear enough. Perhaps your intention was to create a role-playing application to...
After we have done all the playtesting, is time to plan another development cycle. In fact, the work of tuning your application doesn't stop after the first tests. On the contrary, it goes through different iterations many times.
The cycle starts with the planning stage, which includes brainstorming, organizing the work (as we have seen, for instance, in Scrum), and so on. In the next phase, development, we actually create the application, as we did in the last chapter. Then, there is the playtesting, which we have seen in this chapter. In the latter stage, we tune and tweak values, as well as fix bugs in our application.
Afterwards, we iterate the whole cycle again, by entering the planning stage again. Here, we need to plan the next iteration, what should be left, what should be done better, and what to remove. All these decisions should be based on what we have collected in the playtesting stage. The cycle is well represented in the following figure as a spiral...
Data persistence in our application
In the previous chapter, we implemented most of the logic of our application. However, every time the user closes the application, all their tasks disappear. This is because our application is not persisting data.
To make data persistent, we need in some way to store it. The first intuitive way is to store the data locally, which means saving to a file.
Unity offers a quick and easy way to store data persistently by using PlayerPrefs, a special class where there are functions to save primitives, such as integers or strings. In the following examples, we will work with strings, but the process is the same for all the other primitives.
It is possible to save the data by using the following line:
PlayerPrefs.SetString("Your Key", "Your Value");
Basically, it takes a key and a value. The key is important, because we need it when we need to get the value back, maybe in another session (the user used the application, closed...
Connecting our application to a database
In this section, we will explore the different options we have to connect our application to a database. Of course, we are going to see numerous options, but, for sure, this is a good start, especially for those who have never connected an application to a database before.
Why are databases important for playtesting?
First of all, we need to understand why databases are important for playtesting. As we have seen in the previous sections, playtesting is mainly about collecting data from the players/users and using this data to improve our game. However, this data must to be stored somewhere, and that's why a database becomes handy.
In fact, we can store data locally, but this would limit the playtesting to only being in-studio, whereas having a database where our application can send data allows us to distribute beta or alpha versions among playtesters.
Once we have decided to use a database for our application, we have two options...
In this chapter, we have covered the process of playtesting as well as ways to go about it. This includes deciding what you want out of your playtest, where to playtest, and what to ask your playtesters. Then, we looked at how to take this information and use it to improve your game or application. Finally, we learned what data persistence is within our application and how to use PlayerPrefs to save data. Furthermore, we learned why databases are important for playtesting, how to install them, and how to use PlayFab to store our data in an online database.
In the next chapter, we will wrap up everything we did as part of the project. We will make sure that the project is ready to be published and that you have all of the necessary skills to get it to the final stage.
