Module: AG0982A - Creative Research

This blog documents my 3rd year research project at Abertay University. The focus of my research is on video game progression, tutorial design, and how to teach the player. My vision statement could be stated as such:

A game often needs to gradually introduce its mechanics and skills to the player. This needs to be done at such a pace that the player is neither anxious nor bored, and needs to be clear without sacrificing challenge. How can this balance be achieved? To investigate this, I've created a simple puzzle game, and released it to a sample of players. I can use data from their feedback to improve my game.

This issue came to my interest when I noticed that many games do a superb job of gradually teaching a player how to master a complicated system (such as Portal), while many other - often more complicated - games are lacking in comfortable and effective tutorship (such as Crusader Kings II), forcing players to resort to online wiki reading, and YouTube guides.

Saturday 16 April 2016

Implementing OAP: Using My Classmate's Analytics Tool



When I started this project, I was hoping to put some focus on using analytics and user metrics to gather solid feedback on my puzzle game. This would include scripts to track how long it takes a player to complete a level, when certain events occur, and possibly how they move their puzzle pieces. I haven't had time for this, however, but a friend and classmate of mine - Oliver Smith - has made that the focus of his research. The blog explaining his research is available here.

Oliver's Unity package - which he calls Oliver's Analytics Package (OAP) - contains functionality for recording the movement of an object, storing in in an SQL server, and retrieving that data in the Unity editor for viewing and playback. You can watch an object move around the scene as it did when the player was controlling it. This kind of functionality is very useful for game designers, as it allows them to review how players play their games at a glance. Similar tools have been in the arsenal of Bungie Studios and other shooter developers for about a decade now, as seen in their famous heatmaps:


OAP can't compile heatmaps (yet) but it can show me an exact playback of how my players solve my levels. This allows me to review common strategies, common misunderstandings, and any outlying annoyances. It may be very useful for a puzzle game, such as the one I've developed. Additionally, the feedback I gather on how easy it is to use the tool should be useful for Oliver's research.

I can't use the tool without implementing it. Since OAP is custom-made and still in an early stage of development, integrating it to your game isn't a straightforward task. Oliver provided me with a ReadMe file, and communicated with me as I set the tool up to gather data from my game. The process ended up taking about a day of work.

Three objects are at play when using OAP:
- AnConnectScript.cs: The central hub for OAP features. This is where networking settings are applied, and where playback of player movement can be accessed.
- TrackerInfo.cs: This just keeps track of the UserID (UID) and SessionID (SID) for database storage purposes.
- TrackingScript.cs: This is attached to whichever objects the developer wants to track when players are testing the game. In a platformer, this would be the character, but in my case this is the gem puzzle pieces. It gets all of its settings from AnConnectScript.cs.

A few minor usability issues plague Oliver's analytics tool. For example, a line of code needs to be commented or uncommented, depending on which version of Unity you're using. And rather than just having to click one button to download and view data, you have to click several. These, however, are minor inconveniences.

But a major flaw of OAP is how it doesn't play nice with Unity's prefabs. A prefab is a blueprint-like game object stored in Unity's assets, and can be copied into the scene at any time. You use prefabs for any kind of object that needs to be copied in and out of the scene; enemies, pickups, puzzle pieces. Sometimes you want to be able to change a value in the parent prefab that will immediately change the values in all of its in-game copies, such as the damage of an enemy. Sometimes you want to have certain values for each individual copy; maybe each enemy needs its own hairstyle. Unity is sometimes pretty good at guessing when you want all values to reset in unison, or all of them to be individually set. With Oliver's tool, and specifically with the AnConnectScript.cs object, Unity is terrible at this.

As a result, where prefabs would normally be a blessing, here I can't use them. Instead, I need to place a copy of AnConnectScript.cs in each of my game levels, and whenever I want to change a setting, I have to apply the change t each of them separately. With six levels, this is error-prone but doable. With more, it'd start to become a nightmare. So my main sticking point for Oliver has been to find a way around this.

Nonetheless, OAP has been successfully integrated. Next time I send out an iteration of my game for playtesters, I'll be able to review their movement patterns.

(Above: The trails represent the movement of the puzzle pieces recorded from a previous session, where red is the start and blue is the end. The blue gems are what I'm currently using to show where the gem slices were during playback.)


No comments:

Post a Comment