OpenFire - Big data driven networking, analytics, and database.

Games developers should be able to not only easily understand how their players are playing their games, but also quickly and easily react to these observations. With OpenFire, developers are able to quickly and easily integrate world-class big data to perform these tasks.

Introducing OpenFire:

What is OpenFire?

OpenFire is a plugin for IOS and Android Unity games that makes big data easy. Using the same backend that developers like King use as easily as drag-and-drop will feel like cheating, and the edge it will give you over other developers basically is.

OpenFire is a Firebase powered analytics engine for IOS and Android unity games. Firebase can track up to 500 distinct events with up to 50 unique user properties, and utilizes BigQuery to process your data, telling you how your players are playing your game. OpenFire is a fire-and-forget solution, requiring no maintenance and integrating easily with any pre-existing app.

BigQuery lets you see how your players are using your game like never before, and lets you know objectively how your consumers react to gameplay, updates, ad campaigns, and more. Optimizing for maximum player fun and developer profit without a big data solution is almost impossible. With OpenFire, it is incredibly easy.

OpenFire additionally configures (as well as authenticates) the Firebase database for you, giving you unfettered access to one of the most secure and fast databases on the planet. This can easily be used as a multiplayer backend, storage system, or as a way to update your games without pushing anything to the mobile stores.

In depth details

Tracking data events can not only directly inform you on how your players are consuming your product, but they can directly tell you what they do or do not like, allowing you to create a better overall gaming experience. Furthermore, with the advent of tracking data such as ad impressions and in app purchases, more data will directly translate into more profit. This isn’t just buzzword soup, as many other analytics engines may promise. OpenFire creates a development experience that returns simple to understand, simple to act upon data.

Traditionally, data gathering and analysis has been quite difficult, especially for unity. While Unity Analytics and Google Analytics can both provide some useful data, they lack the nuance that is required to get truly meaningful figures from all of the noise that they generate. By providing in-depth context to events, Firebase can give you a precise analysis on why your players behave the way they do when playing your game.

What is context? Context is the situation under which your users performed an action. With Unity Analytics, or Google Analytics, it’s easy to track users performing an action such as clicking on an ad; however, with OpenFire, you can understand the precise conditions the user performed the action under- everything from time spent playing the game, the user’s individual skill, level difficulty, the state of random objects, as well as up to five hundred fully custom contexts.

To further add contexts to event, a user may be tagged with up to 50 fully custom attributes, plus gender, age, and locale. This user attribution can, again, further segment your base; certain products might resonate better with certain genders, and you would have literally no way of knowing without proper data analysis.

Data collection with complex contexts requires no effort at all from the developer, the plugin simply existing in your project will return enormous quantities of analytical data.

The Firebase database stores content in JSON and proliferates file changes throughout the entire user base you have globally within milliseconds. It allows you to do socket-less, easy, networking.

Data examples (pretty graphs):

Some raw event data (just event invocations, no context)

Distribution of the number of times people shared the app on social media vs their win rate.

Red line; visualized X axis (because the data group has value)

Distribution of the number of ad impressions vs player level (sum, not average)

Player win rate vs how many sprinkles they have (sprinkles are an in-game currency)

Features:

  • Automatic user attribute collection upon authentication, to better segment your client base

  • Automatic event state tracking, so that when an event occurs, you know the precise context- templates come with the plugin, but context variables may be set to whatever you want.

  • Native Facebook integration for authentication + refined user attributes

  • Fully customizable authentication- authenticate your users from any API that provides unique user strings, or even authenticate your users from email + password.

  • Anonymous user analytics tracking- your users don’t have to sign in to collect data from them!

  • Exposed Firebase Database SDK; No-effort setup of one of the fastest and most reliable databases on the planet, which is both secure enough to store personal user data and fast enough to backend multiplayer shooters.

  • BigQuery processes your data for you, showing clear as day what influences your user’s behaviors.

Documentation:

**[AVAILABLE ON THE ASSET STORE NOW- HALF OFF]**

If you have any questions, feel free to leave a comment or message me directly.

Plugin developers with questions about OpenFire / seeking to license OpenFire for integration with their plugins may contact me directly via PM, or may contact the team at
superkawaiiltd@gmail.com

Looks interesting, you got my attention we are a company very small one that makes mobile games… We use Bolt , and right now we are using non authoritative for our current game for Android and soon IOS. We are looking for a back end right now we looked in to Game Sparks and a few others, can you tell me the difference between yours and ones like Play Fab, and Game Sparks.

1 Like

Long reply

In it’s current state, OpenFire is an interface with Firebase with a few convenience features; Namely the database management tools, and especially the Analytics tools.

Analytics comparison:
Both GameSparks and PlayFab have analytics services, but they pale in comparison to the juggernaut that is the back-end of OpenFire. The analytical data you get in reports can have up to 50 contexts (the circumstances under which an action happened), and you can effectively poll analytics data as frequently as you wish to. Your data-sets can be plugged into BigQuery, which lets you get actually meaningful data extremely quickly. Knowing the exact circumstances under which a user became a conversion or performed an action of interest is incredibly valuable, and lets you not only segment your users with incredible efficiency, but can also be invaluable for balancing and tweaking your games.

Furthermore (and most importantly), you get access to your player’s google ad ID, and all of the otherwise secret data that comes with that- that is to say you automatically know the majority of your users’s locations, ages, and genders.

Oh; you also get access to your raw data-sets through BigQuery (if you wanted to do anything manually with them for whatever reason)

Database comparison:
PlayFab is hosted on AWS; this means that your users will have different experiences depending on where they are located physically. PlayFab’s database also appears to be difficult to use for custom-fit applications, and does not appear to be very dynamic at all. According to this discussion, you can only have 2 global entries with a limit of 128KB. OpenFire supports arbitrarily sized data for really any purpose; a robust system of rules that can be modified from the admin panel on your database can secure your database, and with that you can really use any data for any purpose (not to mention that we’re adding large binary file support soon).

GameSparks’s solution also appears to be very weak, using a noSQL back-end model with no logic at all. I could not find any information on how this is hosted (which is suspicious), and overall GameSpark’s networking just doesn’t appear to be all that fleshed out.

OpenFire’s database is also run locally (which neither GameSparks or PlayFab are); this means that if your users disconnect from the database, they can still have whatever is local; they can also push to it with no qualms from the db, their data will simply be synced as soon as it is able to.

You can additionally subscribe to an arbitrary number of database paths with OpenFire, meaning that your users can get data the moment it’s ready from hundreds of sources at once, without problems (We’re currently using this functionality in our game Ronin- OpenFire isn’t designed to be a 50 v 50 multiplayer death match, but it sure can be used for one)

Lastly, OpenFire supports Firebase’s Cloud functions, meaning that you can have, if you wish, an authoritative backend that runs code when triggers are hit- though this feature is in beta. Details here;

https://www.youtube.com/watch?v=vr0Gfvp5v1A

1 Like

Oh, and as a side note; We’re going to be building out the functionality to make commonly-requested features part of the OpenFire package (not that you cannot write these yourself, but we’re going to do it for you because you’re busy)

Currently we’re producing

  • Hotloaded tilesets (database powered asset spawning- great for expanding the levels in your game without pushing updates- also gonna support removal / modification of assets from a scene, -even if it’s already in the deployed version of the game-)
  • Tagged interactions (automatic DB calls when the user does something)
  • Action-mapping; automatic actions when some trigger is hit (I.E. if some section you didn’t expect to be difficult is absolutely slaying your users, you can have a text box pop-up and give them a hint- or even make the level a little easier to accommodate for rage-quits)
2 Likes

First module is ready to deploy, added the ability to modularly load a prefab with our HotLoadMessage script on it and have it display in your game!

Adding a general use hot-load asset module next, to be followed up by dynamic level loading!

1 Like

Quick note; if you’re going to be using eval() to hot-load injected code, be sure that the platform you’re on supports non strict javascript! IOS will not eval a javascript string.

If you want to dynamically inject code you NEED to ensure your platform supports it.

Here is one method for code injection. In general, from our findings, IOS does not support -any- dynamic code injection for Javascript, but C# works.

This is going to be a future module by the way.

1 Like

Hotloading is drag-and-drop easy!

Whether you want to hotfix something in your game, or dynamically add levels without pushing updates, OpenFire makes it easy to change your games post-release!

Custom parameters are of course supported, in case you want to dynamically modify arbitrary properties of your gameObjects.

is this asset include authentication? cause we tried adding firebase using there docs authentication and database then build with Unity Cloudbuild… but we got errors in IOS “Undefined symbols for architecture arm64:” and now where having doubt if we buy this asset we could get same result when building it to unity cloudbuild… I’m using windiws 10 btw, thats why we need assets that will not do any in xcode this fix error from ucb