Stencyl SDK

The Stencyl SDK include platform support for iOS and Android.

Requirements

  • Stencyl: 3.1+
  • Haxe 3.1.3+
  • iOS: iOS 7+
  • Android: Android API Level 14

Build size

The download size differ from the actual build size. The additional size of adding GameAnalytics depend on the platform, but it is often very low. For Android it could be as low as 50kb depending on what standard libraries are already included in the game/app.

SETUP

Installation

Download our SDK from the official Github Repository

Or to get a specific version use a link like this (this example will get version 1.0.0):

https://github.com/GameAnalytics/GA-SDK-STENCYL/archive/1.0.0.zip

You are also able to get the latest version of the package directly from our cloud.

Once you have an archive of the package you should follow the next steps:

  1. Open your game.
  2. Go to Settings > Extensions.
  3. Click Install Extension… and pick the GameAnalytics extension downloaded.

The extension is now installed. You’ll need to enable it in each game that needs to use it.

Note: While the extension is enabled on a per-game basis, it is actually installed globally, meaning that you only need to install it once to have it for all your projects.

Alternative installation process

  1. Locate the Stencyl workspace folder (Debug > View > View Workspace Folder).
  2. Unzip the Extension and copy it into [WORKSPACE]/engine-extensions/

Configuring your game(s)

Game Key + Secret Key

For each platform you will need to have a game key and a secret key that will be used during the initialise process. Sign up and go get your keys if you did not have a chance to do it already by this stage.


game key is a unique identifier for your game.
secret key is used to protect event data from being tampered with as it travels to the GameAnalytics servers.

Build

Build is used to specify the current version of your game. Recommended to use a 3 digit version like [major].[minor].[patch]. Notice there is a specific entry for each platform:

 

Custom Dimensions

During gameplay it is possible to set values for 3 different custom dimensions. For each custom dimension it is needed specify a whitelist. You cannot set a custom dimension value unless it is specified in the whitelist first.


For more information about custom dimensions go here.

The dimensions are comma-seperated like shown in the example (remember no space in between each entry):

Resource Currency and Item Types

When submitting resource events you specify a resource currency and resource item type. It is needed to specify a whitelist for each of these. You cannot submit a resource event using other values than specified here.


Each resource currency string should only contain [A-Za-z] characters.

The currencies and item types are comma-seperated like shown in the example (remember no space in between each entry):

Use of a custom ID

The SDK will automatically generate a user id and this is perfectly fine for almost all cases.

Sometimes it is useful to supply this user_id manually – for example if you download raw data for processing and need to match your internal user id (could be a database index on your user table) to the data collected through GameAnalytics.


Do not use a custom user ID unless you have a specific need for using it.


Note that if you introduce this into a game that is already deployed (using the automatic id) it will start counting existing users as new users and your metrics will be affected. Use this from the start of the game lifetime.


When using custom id you need to remember GameAnalytics will first be fully initialized when you have set the custom id. No events can be sent before GameAnalytics is fully initialized.

You can set the custom user ID as in the following example:

Use manual session handling

To enable manual session handling, add the following at the beginning of the game (in the when created block preferably):

Read more about sessions here including manual session handling.

Logging

The info log will output basic information about what is happening when your game is built for native. The verbose log will output the event JSON data that is being sent to the GameAnalytics servers when your game is built for native.

You can enable them as in the following examples:

INITIALIZE SDK

Using the SDK

Now we should be ready for adding code to activate the SDK!
There are 3 phases the SDK will go through.

  1. configuration
  2. initialization
  3. adding events or changing dimensions

Configuration calls configure settings for the SDK and some will not be able to be altered after initialize has been called. Read more about configuration here.

Initialize call will start the SDK and activate the first session. In order to initialise the SDK you will need to include the following blocks into your (early) code blocks.

ADDING EVENTS

About

GameAnalytics feature the following event types.

Event Description
Business In-App Purchases supporting receipt validation on GA servers.
Resource Managing the flow of virtual currencies – like gems or lives.
Progression Level attempts with Start, Fail & Complete event.
Error Submit exception stack traces or custom error messages.
Design Submit custom event id’s. Useful for tracking metrics specifically needed for your game.


Event id’s are strings separated by colons defining an event hierarchy – like “kill:robot:large”. It is important to not generate an excessive amount of unique nodes possible in the event hierarchy tree.

A bad implementation example.
[level_name]:[weapon_used]:[damage_done]

level_name could be 100 values, weapon_used could be 300 values and damage_done could be 1-5000 perhaps. This will generate an event hierarchy with:

100 * 300 * 5000 = 150M possible nodes.

This is far too many. Also the damage should be put as a value and not in the event string. The processing will perhaps be blocked for a game doing this and cause other problems when browsing our tool.

The maximum amount of unique nodes generated should be around 10k.


Please read our event guide here. You will get the most benefit of GameAnalytics when understanding what and how to track.

Business

Business events are used to track in-app purchases with real money.


Mobile games can be hacked and distributed illegally.
Hacking an app will often involve faking/simulating all purchase requests. This will result in several Business events being sent to GameAnalytics for transactions that never occurred.

GameAnalytics provide the option of receipt validation for each purchase sent to GA servers. This process can ensure that revenue metrics reflect the actual spending in your game.


Some configuration is needed before receipt validation will be active.
Read information about validation and requirements for different platforms here.

Receipt validation in Stencyl is supported for the following stores.

  • App Store (iOS)
  • Google Play Store (Android)

The following blocks should be used for sending business events:

 

Resource

Resource events are used to register the flow of your in-game economy (virtual currencies) – the Sink (subtract) and the Source (add) for each virtual currency.


Before calling the resource event it is needed to specify what discrete values can be used for currencies and item types in the Configuration phase.

Source (add) resource events are instrumented with the flow type source: 

Sink (subtract)resource events are instrumented with the flow type sink:


Be careful to not call the resource event too often !

In a game where the user collect coins fairly fast you should not call a Source event on each pickup. Instead you should count the coins and send a single Source event when the user either complete or fail the level.


For more information on the resource event go here .

Progression

Progression events are used to track attempts at completing some part of a game (level, area). A defined area follow a 3 tier hierarchy structure (could be world:stage:level) to indicate what part of the game the player is trying to complete.

When a player is starting a progression attempt a start event should be added. When the player then finishes the attempt a fail or complete event should be added along with a score if needed.

Add a progression start event.

It is not required to use all 3 if your game does not have them.

  • progression01
  • progression01 and progression02
  • progression01 and progression02 and progression03

There can be found the following two more progression event blocks:


For more information on the progression event go here.

Error

Used to track custom error events in the game. You can group the events by severity level and attach a message.

To add a custom error event use the following block:


For more information on the error event go here.

Design

Every game is special. Therefore some needed events might not be covered by our other event types. The design event is available for you to add your own event-id hierarchy.


Please note that custom dimensions and progression filters will not be added on design and error events. Therefore you cannot (at the moment) filter by these when viewing design or error metrics.

To add a design event use the following block method.

It is also possible to add a float value to the event.
This will (in addition to count) make the mean and sum aggregation available in the tool.


It is important to not generate an excessive amount of unique nodes possible in the event hierarchy tree.

A bad implementation example.
[level_name]:[weapon_used]:[damage_done]

level_name could be 100 values, weapon_used could be 300 values and damage_done could be 1-5000 perhaps. This will generate an event hierarchy with:

100 * 300 * 5000 = 1.5M possible nodes.

This is far too many. Also the damage should be put as a value and not in the event string. The processing will perhaps be blocked for a game doing this and cause other problems when browsing our tool.

The maximum amount of unique nodes generated should be around 10k.


Please read our event guide here. You will get the most benefit of GameAnalytics when understanding what and how to track.

CUSTOM DIMENSIONS

Using Custom Dimensions

GameAnalytics supports the use of 3 custom dimensions.

  • Custom01
  • Custom02
  • Custom03

During the game it is possible to set the active value for each custom dimension dynamically. Once a dimension is set it will be persisted across sessions/game-start and automatically be added to these event categories.

  • Business
  • Resource
  • Progression
  • Error
  • Design

Setting each custom dimension. To reset a set custom dimension simply just set it to empty string.


Read more about custom dimensions here.

DEMOGRAPHICS

User Information

During the game it is possible to set information about your users that will then be annotated to all other events.

  • gender
  • birthyear (age)


These user values will persist cross session/game-launch. Set them to empty string to reset.

Set gender.

Set birthyear.

DEBUG & VERIFY

Debugging

The SDK is designed to be as silent as possible and use very few resources. You will therefore not get much information by default in your development console.

We have 2 different debug log types that can be enabled / disabled (at any time or during configuration).

  • info log
  • verbose log

Info log

Short messages will be output when enabled explaining when some action is being performed by the SDK. Sometimes cropping text / values to make it more readable.

Enable info log when implementing the SDK – remember to turn it off in production!

Verbose Log

Console output when each event is added (all fields) in JSON string format. This is the data being submitted to the GA servers for each event.

Enable verbose log when troubleshooting events.

This can result in a lot of text. When troubleshooting/debugging events it is therefore recommended to enable/disable when performing the action that need inspection.

Verify Implementation

Enable the Info Log to verify that events are being sent from your game project without any issues being reported.

Events submitted should register after a minor delay in our realtime dashboard in the GameAnalytics tool.

ℹ Read more about the realtime dashboard and our data processing.

HOW DOES IT WORK?

Session Handling

By default the SDK will handle session start/end automatically, but it is also possible to manually control this yourself.


Be aware that the initialization will always automatically start the first session even with manual session handling. If you are using ads in your game there is a big possibility that the onPause() and onStop() events will be triggered when the ads are showing which will interfere with the session length for information on how to fix this to look here

Automatic session handling

The automatic session handling will track the focused time the user is spending in your game – from game launch to the user leaving the game.

session start
On Android a new session will start once the game is launched or when the app is resumingif there is no current session.

session end
A session will end once the game is going to homescreen (or is not visible anymore).

It will end the session at once if the application received the onStop event from the game activity. It can also end the session if onPause event was received and 90 seconds have passed (sometimes only the onPause will trigger even though the user left the app).

Manual session handling

The automatic session handling only works if the game is contained in one activity.

It will then handle session end and start based on the events on that single activity. This behavior is common (having one activity) but some games define multiple activities and this automatic session handling will not work in an optimal way.

If your game does have multiple activities (or you just want to be in control when to start and end sessions) you can enable/disable manual session handling by calling this at any given time:

You will then need to call endSession and startSession at the appropriate times.


With manual session handling it is recommended to also call endSession when the game activity event onStop is fired. This will ensure a correct session close when users click the home or on/off button.

endSession()

This will end a session if:

  • manual session handling is enabled
  • a session is active
  • SDK is initialized (initialize will start a session automatically)

startSession()

This will start a new session if:

  • manual session handling is enabled
  • SDK is initialized (initialize will start a session automatically)

If a current session is active then it will end the current session and start a new one.

Handling ads and preserve correct session length

Ads will most likely trigger onPause() and onStop() which will interfere with the session length of the game. To prevent this you need to use manual session handling at least when you are about to show ads.

If you are already using manual session handling from the beginning of your game then you don’t need to worry about this.

Behind the scenes

This is what happens when the session is starting or ending.

Session start

  1. Generate new session.
  2. Add a session start event (a “user” event).
  3. Start the periodic activation of submitting queued events.
  4. Next event submit will fix potential missing session_end from earlier sessions.

Session end

  1. Stop the periodic activation of submitting queued events.
  2. Add a session_end event.
  3. Submit queued events.

SETUP

Event Queue

Whenever an event is added (and validated) it will be added to a local database queue.

Interval

Every 8 seconds the SDK will start a task for submitting queued events since last submit. This processing is done in a separate low-priority thread that will have minimum impact on performance. The payload is gzipped and will therefore only consume a small amount of bandwidth.

Offline

When a device is offline the events are still added to the queue. When the device is online it will submit.

Thread Handling

For the Android platform almost every piece of this code is run using a dedicated low-priority serial thread queue to avoid UI lag or sudden performance spikes.

The queue will execute each task sequentially. If the SDK add several tasks to the queue then each will be executed in turn. A task could be adding an event or submitting all queued events.

Consider this example with 3 calls.

The configureBuild is required to be called before initialize is completely finished. The design event call is required after initialise is finished. The queuing will make sure that each task is completely finished before proceeding to the next one.

There is more!

There is much more to GameAnalytics and we suggest that you read our general documentation.

Please create a support ticket if you have any feedback like..

  • bugs
  • confusing features or UI
  • great ideas!

We hope you enjoy our service!