Use GameTracker for Analytics on FGL!

GameTracker is an extremely useful and powerful tool that is available for free here at FGL. With just a little time and effort, you can easily collect pages of data every time your game is played on FGL.

This guide is intended to serve as a sort of checklist for easy implementation along with some tips and tricks for setting it up quickly and painlessly. The official home page for GameTracker are here. You can get everything from there, but here's some quick links: download here and API docs here.

What's New in v1.2:

Version 1.2 was just released, so if you've used GameTracker before, here's what's new:

  • GameTracker now has Singleton support! Call GameTracker from anywhere with a simple call to:GameTracker.api
    • You must call new GameTracker(); before it can be used!
  • alert( ) and customMsg( ) now support single String parameter calls, for example:
    • customMsg(enemy.name+“ destroyed!”);
    • alert(”Super Awesome achievement awarded!”);
  • The score and gameState parameters are now optional and the last recorded values will be used if new ones are not passed in with the function calls.
  • GameTracker Documentation has been updated and is now available here!

Important Functions:

  • alert(customMsg:String = null , currentScore:Number = NaN, currentGameState:String = null):void
  • beginGame(currentScore:Number = NaN, currentGameState:String = null, customMsg:String = null):void
  • beginLevel(newLevel:int, currentScore:Number = NaN, currentGameState:String = null, customMsg:String = null):void
  • checkpoint(currentScore:Number = NaN, currentGameState:String = null, customMsg:String = null):void
  • customMsg(customMsg:String = null, msgType:String = “custom”, currentScore:Number = NaN, currentGameState:String = null):void
  • endGame(currentScore:Number = NaN, currentGameState:String = null, customMsg:String = null):void
  • endLevel(currentScore:Number = NaN, currentGameState:String = null, customMsg:String = null):void

Places to consider implementation: – function call:

  • UI Components (buttons, levelSelect, upgrades, etc) – customMsg();
  • Game Starts – beginGame();
  • Level Begins – beginLevel();
  • Enemies Defeated – customMsg();
  • Common Events – customMsg();
  • Checkpoints Reached – checkpoint();
  • Level Ends – endLevel();
  • Game Over – endGame();
  • Score Submitted – alert();
  • Achievement Awarded – alert();
  • Upgrades/Item Purchases/other important actions – alert();

Step 1 – Make A List: Before taking time to implement an analytics API, like GameTracker, it is important to first figure out exactly what kind of information you would like to track and analyze. To do this, I find it best to play through your own game and think about where it would be helpful to see how the player is interacting with your game. For example, do you know how many players press that mute button? Or how about where most players are struggling with your content? Or how long your players (First Impressions, devs, publishers, etc) are actively playing the game before moving on to another? Sprinkle some GameTracker function calls into your code and you'll have answers to all of those questions in no time!

Step 2 – Initialize The API: Once you have a list of the data that you would like to collect, the next step is to initialize the API to make it ready to use. Start by creating an instance of the GameTracker class somewhere in your code. GameTracker v1.2 now has Singleton support so it no longer matters where the instance is created.

Step 3 – Implement The API: Use the list that you created in Step 1 to locate the best places in your code to add the GameTracker calls that will report the data that you seek. For each location decide which GameTracker function fits best (check the above Important Functions section) and add the calls to your code.

  • Call GameTracker from anywhere with a simple call to: GameTracker.api
    • ie. – GameTracker.api.customMsg(“Player died!”);

Step 4 – Collect The Data: Once the GameTracker API is implemented, collecting the data is as easy as uploading your game to FGL and finding players to play it. Here are a few ideas for finding testers for your game:

  • Request and/or Trade Feedback with other developers in the FGL forums
  • Order First Impressions to have randomly selected players anonymously play your game for at least 5 minutes, rate it (or record it with Video First Impressions), and then hopefully leave some kind of useful feedback
  • Create Fan accounts for your friends and family and ask them to play your game on FGL

Step 5 – Analyze The Data: Every time someone plays your GameTracker enabled game on FGL, the data from their gameplay is recorded and stored in the FGL database. To access this data, all you have to do is go to your game's Views page and find the GameTracker column. If you implemented GameTracker correctly then just about every game view (there may be a few exceptions) should contain a link labeled 'view'. Following the link will take you to the GameTracker Analysis page for that gameplay's data, which contains an overview of the gameplay, a link to view all of the data in detail, and a link to download the detailed data in an easy to analyze csv file.

  • Sample data file: www.edugamedev.com/FGL/Garblactic_session_2231515.csv
  • If GameTracker was not set up correctly or if the player only stayed for a short period of time then the column will read 'N/A' with no link.
  • Download the csv file and use all of your favorite Data Mining tools to help determine trends, averages, and more interesting information!

Tips / Tricks:

  • Use Existing EventListeners – Drop a customMsg( ) call inside existing EventListeners to easily track all events that pass through them:
public function mouseDOWN(event:MouseEvent):void {
    // -- filter out unwanted noise: ie. “instance####”
    if(String(event.target.name).search("instance") != 0){
        GameTracker.api.customMsg(event.target.name + " pressed in Main");
    }

    … // the rest of your mouseDOWN code

}
  • First Impression Quality Assurance – One of the major side benefits of using GameTracker in your game is being able to identify when a FI reviewer is trying to game the system by playing less than 5 minutes and then leaving feedback that is just vague enough to be believable. With GameTracker you can easily see what they did while playing and how long they were actively playing your game, which can then be used as evidence to have bogus FI's replaced with new ones.
  • Publisher Activity – Curious to know what the publishers were doing in your game for over an hour? With GameTracker you don't have to wonder anymore! Since publishers are players too, GameTracker will tell you when they actually started playing your game, how far into the game they got, what options they selected, and whatever else you decide to track.