Category

iPhone

Google Play Game Services for Unity

By | Game Development, iPhone, Technical, Unity | 105 Comments

Google announced Google Game Play Services (GPG) for iOS and Android about 2 days ago at Google I/O. The most important part for us is the ability to save game progress in Google Cloud and realtime Multiplayer game support. This brings Google upto mark with iOS GameCenter.

We just created a plugin for Unity for iOS and Android for GPG with following features

  • Google Cloud Save
  • Leaderboards
  • Achievements
  • Signin/SilentSignin

Google Play Game Services Unity Plugin Demo

In coming weeks we shall add support for Android as well.

Multiplayer matchmaking will be a bit of work since state synch will have to be done from scratch just like it needs to be done for GameCenter. The Unity.Network would not be helpful in multiplayer without a Unity Raknet MasterServer.

The code is available as opensource at https://github.com/faizann/UnityGPGPlugin

Update June 16, 2013

The code now supports Android plugin as well.

Openfeint extension for Marmalade

By | Android, Developer Diary, Game Development, iPhone, Technical | 26 Comments

We wanted to integrate Openfeint in our game BLAZ3D but there was no extension in Marmalade, the game engine we used. We decided to create an Openfeint extension for ourselves.
The extension and relevant documentation is available on Marmalade Github Community repo at[highlight type=”two”]https://github.com/marmalade/openfeint[/highlight]

The extension supports following API
[list style=”arrow” color=”blue”]

  • User login/approval
  • Display of Main dashboard
  • Display of dashboard directly to specific page like Challenges, Acheivements, Leaderoards (iOS Only)
  • Sending of challenges (iOS Only)
  • Highscore submission to leaderboards
  • Acheivement unlock
  • iOS Push Notifications for Openfeint (iOS Only)
[/list]  

Some sample code snippets (Not all API is available on Android as OpenFeint doesn’t support them either)

 

Initialising OpenFeint


s3eNOFSettingVal *settings = (s3eNOFSettingVal*)s3eMalloc(sizeof(s3eNOFSettingVal) * 6);
// Fill settings
// UIOrientation value
strncpy(settings[0].m_varName,
"OpenFeintSettingDashboardOrientation",
S3E_NOPENFEINT_SETTINGS_STRING_MAX);
settings[0].m_intVal = s3eNOFUIInterfaceOrientationPortrait;
//
// Shortdisplay name
strncpy(settings[1].m_varName,
"OpenFeintSettingShortDisplayName",
S3E_NOPENFEINT_SETTINGS_STRING_MAX);
strncpy(settings[1].m_stringVal,
"FunkyRacers",
S3E_NOPENFEINT_STRING_MAX);
// Push Notification Setting
strncpy(settings[2].m_varName,
"OpenFeintSettingEnablePushNotifications",
S3E_NOPENFEINT_SETTINGS_STRING_MAX);
settings[2].m_intVal = 1; // TRUE/YES
//
// Sandbox Notification Mode
strncpy(settings[3].m_varName,
"OpenFeintSettingUseSandboxPushNotificationServer",
S3E_NOPENFEINT_SETTINGS_STRING_MAX);
settings[3].m_intVal = 1;
//
// Disable User generated content
strncpy(settings[4].m_varName,
"OpenFeintSettingDisableUserGeneratedContent",
S3E_NOPENFEINT_SETTINGS_STRING_MAX);
settings[4].m_intVal = 0;
//
// Disable ask for approval in debug mode
strncpy(settings[5].m_varName,
"OpenFeintSettingAlwaysAskForApprovalInDebug",
S3E_NOPENFEINT_SETTINGS_STRING_MAX);
settings[5].m_intVal = 0;
//
s3eNOFArray array;
array.m_count = 6;
array.m_items = settings;
s3eNOFinitializeWithProductKey("PRODUCT_KEY_HERE",
"APP_ID_HERE",
"RacingGame",
&array);
s3eFree(settings);

Launch Main Dashboard after login


// Open Main Dashboard
// s3eNOFlaunchDashboard();

Pull Information about all achievements for user


const unsigned int max_achievements = 20; // whatever we think is max we need
void* data = s3eMalloc(sizeof(s3eNOFAchievement) * max_achievements);
if (data == NULL) {
AppendMessageColour(RED, ("Couldn't allocate data"));
return false;
}
//
s3eNOFArray achArray;
achArray.m_items = data;
achArray.m_count = max_achievements;
s3eNOFachievements(&achArray);
// AppendMessage("Size of achievement %d and double %d",
// sizeof(s3eNOFAchievement),
// sizeof(double));
for (uint i=0; i < achArray.m_count && i < max_achievements; i++) {
// s3eNOFAchievement* ach = &((s3eNOFAchievement*)achArray.m_items[i]);
// AppendMessage("Ach at %p", &((s3eNOFAchievement*)achArray.m_items)[i]);
AppendMessage("Acheivement title %s", ((s3eNOFAchievement*)achArray.m_items)[i].title);

Update December 30, 2011

The extension now supports both Android and iOS. Android API is extremely limited by OpenFeint itself and thus most APIs in extension just return -1 and do nothing.

Analyzing cross-platform engines for mobile phones

By | Android, Developer Diary, Game Development, iPhone | 4 Comments

Quest for Mobile 3D Engine

When we started development on our first title, the first thing as usual was to find our needs and select an engine in accordance to them. After considerable debate, we knew what we really needed was a cross-platform engine for mobile phones which should have solid 3D apis and support as many platforms as possible. This hunt coupled with our naivety as it was our first title, led to us the EdgeLib Engine. Our experiences with it was scarring to say the least, but definitely a huge learning experience which we will leave at that for a post in the future. This made us hunt for a new stronger solution, that we can call our base, our motherland, and that is exactly what we found with Airplay SDK now called Marmalade.

Marmalade is what we call a truly cross-platform engine. Supporting over 6 different os’s, and truly abstracting all api from it is a very big deal, and providing extensive support and a huge array of helping tools is unseen for an engine that supports indie developers. Instead of going into all of its features i will just point out at a few that really caught my eye:

Memory Management

Marmalade provides a very nice solution to manage memory. Instead of giving fast alloc calls and calling it a day, marmalade has a system of buckets. You allocate your data inside buckets, and specify the size of each bucket in a configuration file. This way you know exactly how much memory you are consuming in which area. Secondly, with such a system it becomes easier for marmalade to manage memory, so memory leaks are immediately detected. Add to this system an internal system of tracing call-stacks and you get a system which points to the exact code block that’s causing the leak.

Scalable 3D pipeline

Airplay does not only abstract out basic OS API calls from all platforms, but, due to the largely varying hardware of mobile phones, it also has a scalable 3D pipeline. Support between GLES 2 and GLES 1.0-1.1 in itself is a huge feature and couple that with a low level fallback software renderer and you get a game that would run on any phone in the market, may it have a GPU or not.

The Simulator

Airplay has a solid simulator for emulating the game on the PC/Mac . This simulator extends its features way over what any other phone vendor has provided yet, with features like accelerometer simulation, changing graphics drivers, compass simulation and some very detailed metric of your game. It allows you to configure the simulator in real-time to go as close as possible to the real device. Other than that the metrics the simulator provides are a very handy tool to optimize, showing all API calls made and the number of times they were made. It also tells exact memory usage of each bucket, which is again useful in optimizing your game for low memory use.

The Extra Tools

Airplay provides some very neat external tools, which are integrated which the library very well. Airplay has a system of resource groups and build styles, which allows you to sort out your games data in nice little resource files with which you can easily create multiple editions of your game for different phones and handle all the assests easily using these files. The best part, we just need to specify the compression format in the resource file for each texture, and airplay automatically compresses them on first build, and loads them in-game from the compressed file. This removes a lot of headache like manually converting each texture for different compression techniques for different GPUs. Airplay also provides derbh archive module for game data compression, which coupled with texture compression can reduce your games data by 60-70%!

 

The feature set never ends for this beast of an engine. Of course it has its fall at times too but they are always very minor compared to the huge list of features it give us.

 

[highlight type=”one”]We’ll have to say Marmalade is one of the best mobile 3D Engine we have used for Mobile Game Development.[/highlight]