Game Center Support

With the sad news from InstantAction, I feel that it is more important now than ever to keep iTGB alive. With that, I am going to post instructions on how to integrate Game Center within iTGB. I know that integrating Game Center with Open Feint is easier, but I feel that the two frameworks have a lot of overlapping features and I want to reduce the amount of bloat. If this code has been useful to you, I'd appreciate a War Evolved download :)

There is a lot of setup that you have to do within iTunes Connect to get Game Center to work, so instead of repeating it I'll just point you to the iTunes Connect Game Center docs. Even though the code is here, I still recommend reading the docs to be sure you don't miss anything and can understand what is happening.

Assuming you have iTunes Connect setup, perform the following steps:

1. Create GameCenter.mm and GameCenter.h within the platformiPhone directory in the Xcode Torque project.

2. Add the following to GameCenter.h:

//
//  GameCenter.m
//  Torque2D
//
//  Created by Justin Mosiman on 10/29/10.
//  Copyright 2010 Opsive, LLC. All rights reserved.
//

#import <GameKit/GameKit.h>
#include "console/console.h"
@interface GameCenter : UIViewController <GKLeaderboardViewControllerDelegate, GKAchievementViewControllerDelegate>
{
	BOOL isAuthenticated;
	BOOL gameCenterAvailable;

	UIViewController *gameCenterViewController;
}

@property (nonatomic,retain) UIViewController *gameCenterViewController;

- (void)authenticateLocalPlayer;
- (void)registerForAuthenticationNotification;
- (void)authenticationChanged;
- (BOOL)isAuthenticated;

- (void)reportScore:(int64_t)score forCategory:(NSString*)category;
- (void)reportScore:(GKScore *)scoreReporter;
- (void)saveScoreToDevice:(GKScore *)score;
- (void)retrieveScoresFromDevice;
- (void)showLeaderboard;
- (void)leaderboardViewControllerDidFinish:(GKLeaderboardViewController *)viewController;

- (void)reportAchievementIdentifier:(NSString*)identifier percentComplete:(float)percent;
- (void)reportAchievementIdentifier:(GKAchievement *)achievement;
- (void)saveAchievementToDevice:(GKAchievement *)achievement;
- (void)retrieveAchievementsFromDevice;
- (void)showAchievements;
- (void)achievementViewControllerDidFinish:(GKAchievementViewController *)viewController;

- (void)close;

@end

static GameCenter *gameCenter;

namespace GameCenterWrapper {
	void authenticate();
	void reportScore(int score, int category);
	void reportAchievement(int achievement);
	bool isAuthenticated();
	void showLeaderboard();
	void showAchievements();
	void close();
}

3. Add the following code to GameCenter.mm:

//
//  GameCenter.mm
//  Torque2D
//
//  Created by Justin Mosiman on 10/29/10.
//  Copyright 2010 Opsive, LLC. All rights reserved.
//
#import "platformiPhone/GameCenter.h"

BOOL isGameCenterAvailable()
{
    // Check for presence of GKLocalPlayer API.	
    Class gcClass = (NSClassFromString(@"GKLocalPlayer"));	
	
    // The device must be running running iOS 4.1 or later.	
    NSString *reqSysVer = @"4.1";	
    NSString *currSysVer = [[UIDevice currentDevice] systemVersion];	
    BOOL osVersionSupported = ([currSysVer compare:reqSysVer options:NSNumericSearch] != NSOrderedAscending);	
	
    return (gcClass && osVersionSupported);
}

@implementation GameCenter

@synthesize gameCenterViewController;

//--------------------------------------------------------
// Static functions/variables
//--------------------------------------------------------

static NSString *getGameCenterSavePath()
{
	NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
	return [NSString stringWithFormat:@"%@/GameCenterSave.txt",[paths objectAtIndex:0]];
}

static NSString *scoresArchiveKey = @"Scores";

static NSString *achievementsArchiveKey = @"Achievements";

//--------------------------------------------------------
// Authentication
//--------------------------------------------------------

- (void)authenticateLocalPlayer {
	isAuthenticated = NO; // assume the player isn't authenticated
	gameCenterAvailable = isGameCenterAvailable();
	
	if(!gameCenterAvailable){
		return;
	}
	
	gameCenterViewController = [[UIViewController alloc] init];
	
    [[GKLocalPlayer localPlayer] authenticateWithCompletionHandler:^(NSError *error) {		
		if (error == nil){
			// Insert code here to handle a successful authentication.
			isAuthenticated = YES;
			[self registerForAuthenticationNotification];
			
			// report any unreported scores or achievements
			[self retrieveScoresFromDevice];
			[self retrieveAchievementsFromDevice];
			
			// let the scripts know
			Con::executef(2,"gameCenterAuthenticationChanged","1");
		}else{
			Con::executef(2,"gameCenterAuthenticationChanged","0");
		}
	}];
}

- (void)registerForAuthenticationNotification
{
    NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
    [nc addObserver: self selector:@selector(authenticationChanged) name:GKPlayerAuthenticationDidChangeNotificationName object:nil];
}

- (void)authenticationChanged
{
	isAuthenticated = NO; // assume the player isn't authenticated
	gameCenterAvailable = isGameCenterAvailable();
	
	if(!gameCenterAvailable){
		return;
	}
	
    if ([GKLocalPlayer localPlayer].isAuthenticated){		
        // Insert code here to handle a successful authentication.
		isAuthenticated = YES;
		
		// report any unreported scores or achievements
		[self retrieveScoresFromDevice];
		[self retrieveAchievementsFromDevice];
		
		// let the scripts know
		Con::executef(2,"gameCenterAuthenticationChanged","1");
	}else{
		Con::executef(2,"gameCenterAuthenticationChanged","0");
	}
}

- (BOOL)isAuthenticated
{
	return gameCenterAvailable && isAuthenticated;
}

//--------------------------------------------------------
// Leaderboard
//--------------------------------------------------------

- (void)reportScore:(int64_t)score forCategory:(NSString*)category
{
	if(!gameCenterAvailable)
		return;
	
    GKScore *scoreReporter = [[[GKScore alloc] initWithCategory:category] autorelease];
	if(scoreReporter){
		scoreReporter.value = score;	
		
		[scoreReporter reportScoreWithCompletionHandler:^(NSError *error) {	
			if (error != nil){
				// handle the reporting error
				[self saveScoreToDevice:scoreReporter];
			}
		}];	
	}
}

- (void)reportScore:(GKScore *)scoreReporter
{
	if(!gameCenterAvailable)
		return;
	
	if(scoreReporter){
		[scoreReporter reportScoreWithCompletionHandler:^(NSError *error) {	
			if (error != nil){
				// handle the reporting error
				[self saveScoreToDevice:scoreReporter];
			}
		}];	
	}
}

- (void)saveScoreToDevice:(GKScore *)score
{
	NSString *savePath = getGameCenterSavePath();
	
	// If scores already exist, append the new score.
	NSMutableArray *scores = [[[NSMutableArray alloc] init] autorelease];
	NSMutableDictionary *dict;
	if([[NSFileManager defaultManager] fileExistsAtPath:savePath]){
		dict = [[[NSMutableDictionary alloc] initWithContentsOfFile:savePath] autorelease];
		
		NSData *data = [dict objectForKey:scoresArchiveKey];
		if(data) {
			NSKeyedUnarchiver *unarchiver = [[NSKeyedUnarchiver alloc] initForReadingWithData:data];
			scores = [unarchiver decodeObjectForKey:scoresArchiveKey];
			[unarchiver finishDecoding];
			[unarchiver release];
			[dict removeObjectForKey:scoresArchiveKey]; // remove it so we can add it back again later
		}
	}else{
		dict = [[[NSMutableDictionary alloc] init] autorelease];
	}
	
	[scores addObject:score];
	
	// The score has been added, now save the file again
	NSMutableData *data = [NSMutableData data];	
	NSKeyedArchiver *archiver = [[NSKeyedArchiver alloc] initForWritingWithMutableData:data];
	[archiver encodeObject:scores forKey:scoresArchiveKey];
	[archiver finishEncoding];
	[dict setObject:data forKey:scoresArchiveKey];
	[dict writeToFile:savePath atomically:YES];
	[archiver release];
}

- (void)retrieveScoresFromDevice
{
	NSString *savePath = getGameCenterSavePath();
	
	// If there are no files saved, return
	if(![[NSFileManager defaultManager] fileExistsAtPath:savePath]){
		return;
	}
	
	// First get the data
	NSMutableDictionary *dict = [NSMutableDictionary dictionaryWithContentsOfFile:savePath];
	NSData *data = [dict objectForKey:scoresArchiveKey];
	
	// A file exists, but it isn't for the scores key so return
	if(!data){
		return;
	}
	
	NSKeyedUnarchiver *unarchiver = [[NSKeyedUnarchiver alloc] initForReadingWithData:data];
	NSArray *scores = [unarchiver decodeObjectForKey:scoresArchiveKey];
	[unarchiver finishDecoding];
	[unarchiver release];
	
	// remove the scores key and save the dictionary back again
	[dict removeObjectForKey:scoresArchiveKey];
	[dict writeToFile:savePath atomically:YES];
	
	
	// Since the scores key was removed, we can go ahead and report the scores again
	for(GKScore *score in scores){
		[self reportScore:score];
	}
}

- (void)showLeaderboard
{
	if(!isAuthenticated)
		return;
	
    GKLeaderboardViewController *leaderboardController = [[GKLeaderboardViewController alloc] init];	
    if (leaderboardController != nil) {
        leaderboardController.leaderboardDelegate = self;
		
		UIWindow* window = [UIApplication sharedApplication].keyWindow;
		[window addSubview: gameCenterViewController.view];
        [gameCenterViewController presentModalViewController: leaderboardController animated: YES];
    }	
}

- (void)leaderboardViewControllerDidFinish:(GKLeaderboardViewController *)viewController
{
    [gameCenterViewController dismissModalViewControllerAnimated:YES];
	[viewController.view removeFromSuperview];
	[viewController release];
}

//--------------------------------------------------------
// Achievements
//--------------------------------------------------------

- (void)reportAchievementIdentifier:(NSString*)identifier percentComplete:(float)percent
{
	if(!gameCenterAvailable)
		return;
	
    GKAchievement *achievement = [[[GKAchievement alloc] initWithIdentifier: identifier] autorelease];	
    if (achievement){		
		achievement.percentComplete = percent;		
		[achievement reportAchievementWithCompletionHandler:^(NSError *error){
			if (error != nil){
				[self saveAchievementToDevice:achievement];
			}		 
		}];
    }
}

- (void)reportAchievementIdentifier:(GKAchievement *)achievement
{	
	if(!gameCenterAvailable)
		return;
	
    if (achievement){		
		[achievement reportAchievementWithCompletionHandler:^(NSError *error){
			if (error != nil){
				[self saveAchievementToDevice:achievement];
			}		 
		}];
    }
}

- (void)saveAchievementToDevice:(GKAchievement *)achievement
{
	
	NSString *savePath = getGameCenterSavePath();
	
	// If achievements already exist, append the new achievement.
	NSMutableArray *achievements = [[[NSMutableArray alloc] init] autorelease];
	NSMutableDictionary *dict;
	if([[NSFileManager defaultManager] fileExistsAtPath:savePath]){
		dict = [[[NSMutableDictionary alloc] initWithContentsOfFile:savePath] autorelease];
		
		NSData *data = [dict objectForKey:achievementsArchiveKey];
		if(data) {
			NSKeyedUnarchiver *unarchiver = [[NSKeyedUnarchiver alloc] initForReadingWithData:data];
			achievements = [unarchiver decodeObjectForKey:achievementsArchiveKey];
			[unarchiver finishDecoding];
			[unarchiver release];
			[dict removeObjectForKey:achievementsArchiveKey]; // remove it so we can add it back again later
		}
	}else{
		dict = [[[NSMutableDictionary alloc] init] autorelease];
	}
	
	
	[achievements addObject:achievement];
	
	// The achievement has been added, now save the file again
	NSMutableData *data = [NSMutableData data];	
	NSKeyedArchiver *archiver = [[NSKeyedArchiver alloc] initForWritingWithMutableData:data];
	[archiver encodeObject:achievements forKey:achievementsArchiveKey];
	[archiver finishEncoding];
	[dict setObject:data forKey:achievementsArchiveKey];
	[dict writeToFile:savePath atomically:YES];
	[archiver release];	
}

- (void)retrieveAchievementsFromDevice
{
	NSString *savePath = getGameCenterSavePath();
	
	// If there are no files saved, return
	if(![[NSFileManager defaultManager] fileExistsAtPath:savePath]){
		return;
	}
	
	// First get the data
	NSMutableDictionary *dict = [NSMutableDictionary dictionaryWithContentsOfFile:savePath];
	NSData *data = [dict objectForKey:achievementsArchiveKey];
	
	// A file exists, but it isn't for the achievements key so return
	if(!data){
		return;
	}
	
	NSKeyedUnarchiver *unarchiver = [[NSKeyedUnarchiver alloc] initForReadingWithData:data];
	NSArray *achievements = [unarchiver decodeObjectForKey:achievementsArchiveKey];
	[unarchiver finishDecoding];
	[unarchiver release];
	
	// remove the achievements key and save the dictionary back again
	[dict removeObjectForKey:achievementsArchiveKey];
	[dict writeToFile:savePath atomically:YES];
	
	// Since the key file was removed, we can go ahead and try to report the achievements again
	for(GKAchievement *achievement in achievements){
		[self reportAchievementIdentifier:achievement];
	}
}

- (void)showAchievements
{	
	if(!isAuthenticated)
		return;
	
    GKAchievementViewController *achievements = [[GKAchievementViewController alloc] init];	
    if (achievements != nil){
        achievements.achievementDelegate = self;
		
		UIWindow* window = [UIApplication sharedApplication].keyWindow;
		[window addSubview: gameCenterViewController.view];
        [gameCenterViewController presentModalViewController: achievements animated: YES];
    }	
}

- (void)achievementViewControllerDidFinish:(GKAchievementViewController *)viewController
{
    [gameCenterViewController dismissModalViewControllerAnimated:YES];
	[viewController.view removeFromSuperview];
	[viewController release];
}

//--------------------------------------------------------
// Goodbye
//--------------------------------------------------------

- (void)close
{
	[gameCenterViewController release];
}

@end


//--------------------------------------------------------
// Wrapper
//--------------------------------------------------------

void GameCenterWrapper::authenticate(){
	if(isGameCenterAvailable()){
		gameCenter = [[GameCenter alloc] init];
		[gameCenter authenticateLocalPlayer];
	}
}

// 
// If the category names are updated, make sure they are also updated in iTunes Connect.
// 
void GameCenterWrapper::reportScore(int score, int category){
	NSString *categoryID = [[NSString alloc] autorelease];
	switch (category){
		case 0:
			categoryID = @"YOUR_CATEGORY_ID_0";
			break;
		case 1:
			categoryID = @"YOUR_CATEGORY_ID_1";
			break;
	}
	
	[gameCenter reportScore:score forCategory:categoryID];
}

void GameCenterWrapper::reportAchievement(int achievement){
	NSString *achievementID = [[NSString alloc] autorelease];
	switch (achievement){
		case 0:
			achievementID = @"YOUR_ACHIEVEMENT_ID_0";
			break;
		case 1:
			achievementID = @"YOUR_ACHIEVEMENT_ID_1";
			break;
	}
	
	[gameCenter reportAchievementIdentifier:achievementID percentComplete:100.0f]; // no partial achievements
}

bool GameCenterWrapper::isAuthenticated(){
	return [gameCenter isAuthenticated];
}

void GameCenterWrapper::showLeaderboard(){
	[gameCenter showLeaderboard];
}

void GameCenterWrapper::showAchievements(){
	[gameCenter showAchievements];
}

void GameCenterWrapper::close(){
	if(isGameCenterAvailable()){
		[gameCenter close];
		[gameCenter release];
	}
}

ConsoleFunction(isGameCenterAvailable,bool,1,1,"()")
{
	return isGameCenterAvailable();
}

ConsoleFunction(authenticateGameCenter,void,1,1,"")
{
	GameCenterWrapper::authenticate();
}

ConsoleFunction(reportGameCenterScore,void,3,3,"(score, category id)")
{
	GameCenterWrapper::reportScore(dAtoi(argv[1]),dAtoi(argv[2]));
}

ConsoleFunction(unlockGameCenterAchievement,void,2,2,"(achievement id)")
{
	GameCenterWrapper::reportAchievement(dAtoi(argv[1]));
}

ConsoleFunction(isGameCenterAuthenticated,bool,1,1,"")
{	
	return GameCenterWrapper::isAuthenticated();
}

ConsoleFunction(showGameCenterLeaderboard,void,1,1,"")
{
	GameCenterWrapper::showLeaderboard();
}

ConsoleFunction(showGameCenterAchievements,void,1,1,"")
{
	GameCenterWrapper::showAchievements();
}

ConsoleFunction(closeGameCenter,void,1,1,""){
	GameCenterWrapper::close();
}

4. Update GameCenterWrapper::reportScore() and GameCenterWrapper::reportAchievement() to include the score category/achievement id that was set in iTunes Connect.

5. To initialize Game Center, call the following Torque Script function:

authenticateGameCenter();

I put it in the initializeProject() function within game/main.cs. It needs to be one of the first things called once iTGB has initialized.

6. To close Game Center, call:

closeGameCenter();

I put it within shutdownProject() of game/main.cs.

7. To add a high score, call:

reportGameCenterScore(%score,%category);

8. To award an achievement, call:

unlockGameCenterAchievement(%achievementID);

9. To show the leaderboard GUI, call:

showGameCenterLeaderboard();

10. To show the achievements GUI, call:

showGameCenterAchievements();

11. The Torque Script function gameCenterAuthenticationChanged(%isAvailable) is called whenever the authentication changes. Add this function somewhere in your game to handle logging into Game Center, such as showing the achievements or leaderboard.

Note that it is up to you to decide how you want to indicate that an achievement was achieved. There are more Game Center related functions exposed, and you can decide if you need to use them, but I haven't found a use for them.

If this code has been useful to you, I'd appreciate a War Evolved download :)

Justin