[OpenFeint Developer Support Center] Most Popular Articles

OpenFeint Basics

Wed, 28 Apr 2010 21:55:21 GMT

Initializing OpenFeint
OpenFeint is initialized with one function call:

[OpenFeint
initializeWithProductKey:andSecret:andDisplayName:andSettings:andDelegates:];

ProductKey and Secret are strings obtained by registering your application at https://api.openfeint.com
DisplayName is the string name we will use to refer to your application throughout OpenFeint.
Settings is dictionary of settings (detailed below) that allow you to customize OpenFeint.
Delegates is a container object that allows you to provide desired delegate objects pertaining to specific OpenFeint features.

Shutting down OpenFeint
OpenFeint shutdown is accomplished with one function call:
[OpenFeint shutdown];

Additional required functions
Developers are required to notify OpenFeint of device lock / unlock events in order to reduce processing and save battery.

[OpenFeint applicationDidBecomeActive];

This method should be invoked from the UIApplicationDelegate object's applicationDidBecomeActive: method.

[OpenFeint applicationWillResignActive];

This method should be invoked from the UIApplicationDelegate object's applicationWillResignActive: method.

OpenFeint configuration settings
Settings are provided to OpenFeint as an NSDictionary. Here is an example of creating a settings dictionary for use with the initialize method:

NSDictionary* settings = [NSDictionary dictionaryWithObjectsAndKeys:
    [NSNumber numberWithInt:UIInterfaceOrientationLandscapeLeft], OpenFeintSettingDashboardOrientation,
    @"ShortName", OpenFeintSettingShortDisplayName, 
    NSNumber numberWithBool:YES], OpenFeintSettingEnablePushNotifications,
    [NSNumber numberWithBool:NO], OpenFeintSettingDisableChat,
    nil
];

More detail for each of these settings can be found below. These settings are also described in OpenFeintSettings.h.

OpenFeintSettingRequireAuthorization - deprecated
OpenFeintSettingDashboardOrientation - Specifies which orientation the OpenFeint dashboard will appear in
OpenFeintSettingShortDisplayName - In certain areas where the application display name can be too long we will use this more compact version of your application's display name. One example is for the title of the current game tab in the OpenFeint dashboard.
OpenFeintSettingEnablePushNotifications - This controls whether or not your application will be enabling Push Notifications (for Social Challenges, currently)
OpenFeintSettingDisableChat - Allows a developer to disable chat for their entire application.

What is OFDelegatesContainer? Where is OpenFeintDelegate?
OFDelegatesContainer is new as of version 2.1 and provides developers a way to specify all of the various delegates that OpenFeint features may require.

If you are only using an OpenFeintDelegate then you may use the simple convenience constructor:
[OFDelegatesContainer containerWithOpenFeintDelegate:];

What is OpenFeintDelegate for?
This is the bread-and-butter OpenFeint delegate.

- (void)dashboardWillAppear;

This method is invoked whenever the dashboard is about to appear. We suggest that application developers use this opportunity to pause any logic / drawing while OpenFeint is displaying.

- (void)dashboardDidAppear;

This method is invoked when the dashboard has finished it's animated transition and is now fully visible.

- (void)dashboardWillDisappear;

This method is invoked when the dashboard is about to animate off the screen. We suggest that applications that do not use OpenGL resume drawing in this method.

- (void)dashboardDidDisappear;

This method is invoked when the dashboard is completed off the screen. We suggest that OpenGL applications resume drawing here, and all applications resume any paused logic / gameplay here.

- (void)userLoggedIn:(NSString*)userId;

This method is invoked whenever an application successfully connects to OpenFeint with a logged in user. The single parameter is the OpenFeint user id of the logged in user.

- (BOOL)showCustomOpenFeintApprovalScreen;

This method is invoked when OpenFeint is about to show the welcome / approval screen that asks a user if they would like to use OpenFeint. You can learn more about customizing the approval screen here.

OFNotificationDelegate
This delegate deals with the in-game notification pop-ups that OpenFeint displays in response to certain events including high score submission, achievement unlocks, and social challenges. You can find more details by referencing the API feature article on notification pop-ups.

OFChallengeDelegate
This delegate deals with the Social Challenges API feature. You can find more details by referencing the Social Challenges feature article.

Launching the OpenFeint dashboard
The most basic launch of the OpenFeint dashboard is accomplished with a single function call:
[OpenFeint launchDashboard];

You can also launch the dashboard with a specific OpenFeintDelegate for use only during this launch using:
[OpenFeint launchDashboardWithDelegate:];

In addition, OpenFeint provides a suite of methods for launching the dashboard to a pre-defined tab or page. These are documented in the header file OpenFeint+Dashboard.h.

+ (void)launchDashboardWithListLeaderboardsPage;

Invoke this method to launch the OpenFeint dashboard to the leaderboard list page for your application.

+ (void)launchDashboardWithHighscorePage:(NSString*)leaderboardId;

Invoke this method to launch the OpenFeint dashboard to a specific leaderboard page. You must pass in a string representing the unique ID of the leaderboard you wish to view which can be obtained from the Developer Dashboard.

+ (void)launchDashboardWithAchievementsPage;

Invoke this method to launch the OpenFeint dashboard to the achievements list page for your application.

+ (void)launchDashboardWithChallengesPage;

Invoke this method to launch the OpenFeint dashboard to the challenge list page for your application.

+ (void)launchDashboardWithFindFriendsPage;

Invoke this method to launch the OpenFeint dashboard to the 'find friends' page, which prompts the user to use twitter, facebook, or a username search to locate friends in OpenFeint.

+ (void)launchDashboardWithWhosPlayingPage;

Invoke this method to launch the OpenFeint dashboard to a page which lists OpenFeint friends who are also playing your application.

Orientation and View Controller information
The OpenFeint dashboard supports being displayed in any orientation you desire. It will not, however, change orientations while it is being displayed.

Developers use the OpenFeintSettingDashboardOrientation to control the initial orientation. If you wish to change the orientation over the course of the application you may invoke:
[OpenFeint setDashboardOrientation:];

Generally this is done by applications which want to support multiple orientations in the UIViewController method didRotateFromInterfaceOrientation:.

If your application is using a view controller with a non-portrait layout then you are required to invoke and return the following method in your UIViewController's shouldAutorotateToInterfaceOrientation method.
[OpenFeint shouldAutorotateToInterfaceOrientation:withSupportedOrientations:andCount:];

Here is an example implementation of shouldAutorotateToInterfaceOrientation:

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
{
    const unsigned int numOrientations = 4;
    UIInterfaceOrientation myOrientations[numOrientations] = 
    { 
        UIInterfaceOrientationPortrait, UIInterfaceOrientationLandscapeLeft, 
        UIInterfaceOrientationLandscapeRight, UIInterfaceOrientationPortraitUpsideDown
    };

    return [OpenFeint 
        shouldAutorotateToInterfaceOrientation:interfaceOrientation 
        withSupportedOrientations:myOrientations 
        andCount:numOrientations];
}

Integrate OpenFeint in 19 minutes

Thu, 05 Nov 2009 21:29:20 GMT

Check out this screencast made by Alan Taylor. He shows you how to setup a simple application with OpenFeint and Achievements in 19 minutes flat! Thanks to Alan for making this screencast!

creating an OpenFeint iPhone app from scratch from Alan Taylor on Vimeo.

OpenFeint Developer FAQ

Fri, 28 May 2010 23:35:25 GMT

Q: How much does it cost to use OpenFeint?
A: All of OpenFeint’s core features, Leaderboards, Achievements, Challenges, and Social Notifications, are free to use.

Q: Where can I read the OpenFeint License Agreement?
A: The license agreement appears when you submit a game for approval and is also available in the help center here.

Q: When should I submit my game for OpenFeint approval? How long does it take?
A: As soon as you are ready to submit your game for Apple approval or have completed OpenFeint integration. Approvals generally take 2-3 days.

Q: Where can I download art assets?
A: OpenFeint icons and art assets are located within the Developer Dashboard under “OF Icon” along the left hand navigation. Scroll to the bottom of the page to download the .zip file. Also be sure to check out our branding guidelines.

Q: Is it possible to access the leaderboards and display them on our web site?
A: Leaderboards are not accessible via the web right now. We are in the process of planning how we're going to expose our APIs for use via other web pages.

Q: How do I change the name of my company in the developer dashboard?
A: We're adding this into an update of the developer dashboard, but in the meantime email us at devsupport@openfeint.com and we can take care of it for you.

Integration Questions:

Q: Is there a forum where I can discuss integration issues?
A: YES! Please visit the OpenFeint Developer Forum. Note that for the fastest response, it’s best to contact us via the form located at the top of this page.

Q: Can I have my free game and paid game share a leaderboard?
A: Yes, you can. Check out this article: Using OpenFeint to upsell from free to paid.

Q: I’m having trouble decompressing the Unity support package.
A: We’re aware of an issue with developers still using the Leopard OS. Download a Leopard-friendly version of the package here.

Q: How do I get notifications to come from the top of the screen?
A: Set OpenFeintSettingInvertNotifications to true when initializing OpenFeint to show notifications from top.

Q: I’m running into a lot of build errors. What’s wrong?
A: Check out the Build Error FAQ for some possible solutions to common build errors.

Q: Is there an API call I can use to tell if the user has opted-in or out from using OpenFeint?
A: [OpenFeint hasUserApprovedFeint]

Q: Is there a notification for when the OpenFeint dashboard closes so that I know when to stop running animations and when to start?
A: You'll want to have a look in OpenFeintDelegate.h. When you initialize OpenFeint you should be providing a delegate which adopts this protocol.
You should stop the animations in this delegate method:
(void)dashboardWillAppear;
for cocoa games you should resume then in:
and for OpenGL games you should resume them in:
(void)dashboardDidDisappear;
You are free to create your own notification and post it within these delegate methods if you need to get these events passed along to other objects.

Q: What happens to a high score when a player is offline?
A: As of OpenFeint 2.1 high scores are queued for submission when the player is offline and submitted when next he's online again.

Q: Does OpenFeint use encryption?
A: OpenFeint uses HTTPS for all communication between the client and our servers.

Promotions:

Q: I’m approved and my game is available in the App Store, why isn’t it showing up in the game catalog?
A: The OpenFeint game catalog usually updates within 3 days. If it’s been longer than 7 please contact us so that we can investigate.

Q: What is the criteria for becoming an OpenFeint Gold Game? How can I apply?
A: OpenFeint Gold requirements are outlined in this support article. To apply for Gold, or any of our other promotional opportunities, please check out the OpenFeint Gold section of the developer dashboard.

Q: How do I apply for Free Game Of The Day?
A: Apply for Free Game Of The Day here: Free Game Of The Day FAQ

Leaderboards

Fri, 15 Jan 2010 21:55:34 GMT

Overview

OpenFeint leaderboards are a powerful yet simple way of encouraging social competition in your game. Leaderboards in OpenFeint have the following behaviors:

High Scores can either be ranked globally or filtered by a player’s friends.
High Scores can be sorted in ascending or descending order.
Each player can have one ranked score per leaderboard.
A game can have an unlimited number of leaderboards.
Leaderboards can be named whatever you’d like.
Leaderboards are not shared across games.
You can restrict leaderboards by your game’s bundle version.
Score submitted when offline will be sent to the server the next time they are playing online
If displayText is passed when submitting that is shown in the high score list instead of the score

What is an aggregate leaderboard?

OpenFeint supports aggregate leaderboards that allow you to summarize any number of other leaderboards. These are useful when you want to have a set of leaderboards all contribute to another leaderboard.

Quick Start

Add a leaderboard to your application from the Developer Portal.
Note the Unique Identifier of your new leaderboard.
In your application, submit the player’s score like this

[OFHighScoreService setHighScore: scoreGoesHere forLeaderboard:@"leaderboard_id_string" onSuccess:OFDelegate() onFailure:OFDelegate()];

Downloading leaderboard data for custom display

If you wish to download leaderboard data to display inside your game please have a look at OFHighScoreService.h. The scores are "paginated", meaning you can only request a certain number of records at a time

 
[OFHighScoreService getPage:1 forLeaderboard:@"leaderboard_id_string" friendsOnly:NO silently:YES onSuccess:OFDelegate(self, @selector(_scoresDownloaded:)) onFailure:OFDelegate(self, @selector(_failedDownloadingScores))];
 
- (void)_scoresDownloaded:(OFPaginatedSeries*)page
{
    NSMutableArray* highscores = nil;
 
    if ([page count] > 0)
    {
        if ([[page objectAtIndex:0] isKindOfClass:[OFTableSectionDescription class]])
        {
            // NOTE: In the following line, we access "[page objectAtIndex:1]" to retrieve high scores from
            // the global leaderboard.  Using "[page objectAtIndex:0]" would retrieve scores just for the local player.
            // Older versions of OpenFeint did not break this out into 2 sections.
            highscores = [(OFTableSectionDescription*)[page objectAtIndex:1] page].objects;
        }
        else
        {
            highscores = page.objects;
        }
    }
 
    for (OFHighScore* score in highscores)
    {
        // ...
    }
}
- (BOOL)canReceiveCallbacksNow
{
    return YES;
}

You'll end up with a 'highscores' NSMutableArray that contains a number of OFHighScore objects which describe the user who submitted the high score, their rank, and their score.

Header Files

OFLeaderboardService.h
OFLeaderboard.h
OFHighScoreService.h
OFHighScore.h

Integrating the OpenFeint SDK

Wed, 07 Apr 2010 21:40:15 GMT

OpenFeint is written in Objective-C++! This means that any and all files which invoke OpenFeint methods must be compiled with Objective-C++. The simplest way to compile with Objective-C++ is to change your file extension to .mm

Compiling and Linking the OpenFeint SDK

Make sure you have the current version of OpenFeint. Unzip the file.
If you have previously used OpenFeint, delete the existing group reference from your project
Drag and drop the unzipped folder titled OpenFeint onto your project in XCode. Make sure it’s included as a group and not a folder reference.
If your game is landscape only or portrait only, remove the Resources/Landscape or Resources/Portrait folder from your project, whichever you don't need. This is not a necessary step but helps cut down the application size. You need to do this every time you download a new OpenFeint project.
Right click on your project icon in the Groups & Files pane. Select Get Info.
- Select the Build tab. Make sure you have Configuration set to All Configurations
- Add to Other Linker Flags the value -ObjC
- Ensure 'Call C++ Default Ctors/Dtors in Objective-C' is checked under the 'GCC 4.2 - Code Generation' section
- NOTE: Older Xcode projects may have to add this as a user defined setting GCC_OBJC_CALL_CXX_CDTORS set to YES
Ensure the following frameworks are included in your link step:
- Foundation
- UIKit
- CoreGraphics
- QuartzCore
- Security
- SystemConfiguration
- libsql3.0.dylib
- libz.1.2.3.dylib (unless using OF_EXCLUDE_ZLIB as described below)
You must have a prefix header. It must have the following line: #import “OpenFeintPrefix.pch”

Cool, it compiles now but I get a lot of build output spam related to XIB files
We are working to reduce and eliminate these notices. They annoy us too! You can disable these notices from appearing if you find that you are missing valid warnings and errors among the spam by following these steps:

Open the Project Settings in Xcode and go to the Build tab.
Look for the 'Show Notices' setting under the heading 'Interface Builder Compiler'
Make sure this setting is disabled / unchecked.

Note: If you are unable to find the 'Show Notices' setting you may add a User-Defined Setting named 'IBC_NOTICES' and set it to 'NO'.

Changes from 2.4 to 2.4.5 are listed below:

High Score blobs use zlib for compression.

If you don't want to include the zlib framework then add OF_EXCLUDE_ZLIB to your preprocessor definitions. This will disable compression
If you want to use compression then include the libz.1.2.3.dylib framework

There is now a setHighScore function in OFHighScoreService that takes in a NSData* parameter for the blob
There is a new setting called OpenFeintSettingDisableCloudStorageCompression. Set it to true to disable compression. This is global for all high score blobs.
There is a new setting called OpenFeintSettingOutputCloudStorageCompressionRatio. When set to true it will print the compression ratio to the console whenever compressing a blob.

For information about basic OpenFeint usage, settings, and initialization continue to OpenFeint Basics

Challenges

Fri, 06 Nov 2009 00:03:53 GMT

Overview

OpenFeint Challenges add replay value and depth to your game and are also very viral. The high concept is that a user plays a game session of some sort, game data is recorded and stored on the OpenFeint servers, and a challenge is sent out to one or more of the players friends. Challenges are received as push notifications as well as in-game notifications. When a user receives a challenge he may decide to accept it after which he plays a similar game session trying to beat the challenge. There is much flexibility in the implementation however and a developer may use challenges in many different ways.

All challenges may be split into two categories.

One Shot Challenges allow the recipient a single try to beat the challenge. This always results in a win, lose or tie. This is a heads on competition in the sense that either player can win, it fits casual gaming and can be used in many different scenarios.
Multiple Attempt Challenges allow the recipient unlimited attempts at beating the challenge. The challenge is not considered completed until beaten so the only things recorded are the number of attempts and whether or not it's completed. Once a user completes a challenge he may challenge back to the person who sent the challenge with the result of the session he just played. This builds a dynamic where two players may keep sending each other harder and harder challenges.

Challenges are only loosely defined by the API. Depending on the implementation the experience and scope may vary greatly. Here are some possible scenarios but this list is by no means exhaustive.

- User selects to create a challenge through in game menus.
- User plays a short game session.
- User is presented with a list of friends he may send the challenge to.
- User selects a friend to challenge from in game menus.
- User plays a short game session.
- The challenge is automatically sent to the recipient the user picked before starting the game session.
- User plays a level through regular game play.
- User is given the option to send the level results as a challenge through in game menu.
- User is presented with an OpenFeint screen where he may select friends to send the challenge to.

The nature of a challenge is also up to the developer. A challenge may contain any data so it could be used for something as complicated as recording the path of a car in a racing game and then allowing another user to race that car in a challenge as a ghost race. It can also be a simple as trying to beat a specific score in a specific level.

Resources
To get the id of a resource access it's resourceId property. Whenever OpenFeint expects a challengeToUserId parameter that means the resourceId of a OFChallengeToUser etc.

OFChallengeDefinition defines a type of challenge. Title, icon, etc. These are created in the developer dash board and referenced by a unique ID.
OFChallenge is a challenge created by a user. It contains the challenger and all the information about the actual challenge but it does not contain any recipients. Think of it as a free floating challenge that's not aimed at anyone in particular. Each challenge may be the "parent" of many OFChallengeToUsers who contain the recipients.
OFChallengeToUser is a challenge sent to a specific user. On challenge may map to many OFChallengeToUsers. It contains the challenge, the recipient and the status of the challenge (completed, result, etc).

Quick Start

It is recommended to set up push notifications to get the most out of challenges. Instructions can be found at http://help.openfeint.com/faqs/api-features/pushnotifications.

This describes the implementation of the first scenario listed above which is likely the most common one. The basic functionality is the same for all scenarios and it should be easy to modify this example to fit your needs.

Create your Challenge Definitions on the OpenFeint developer dashboard. The icon should be of size 44x44.

Creating a challenge

To create a challenge the user must have approved OpenFeint. You may find this out by calling [OpenFeint hasUserApprovedFeint]. If the user has not approved OpenFeint , call [OpenFeint presentUserFeintApprovalModal] and only proceed to the next step if the approved delegate gets called.
To send out a challenge the user needs to be online. Find this out by calling [OpenFeint isOnline]. If the user is not online you may deny him creating the challenge or still allow him to create it after notifying him that it may not be sent.
To send out a challenge the user needs friends to send it to. Find this out by calling [OFFriendsService isLocalUserFollowingAnyone]. If the user is not following anyone it's recommended you let him find friends in the dashboard. You may launch the dashboard with the find friends page by calling [OpenFeint launchDashboardWithFindFriendsPage]. You may also let the user start the challenge after first notifying him that he will not be able to send it to anyone.
Have your app delegate (or some other appropriate object) conform to OFChallengeDelegate and pass it in when initializing OpenFeint.
In your in-game menu, add an option for the user to create a challenge. Optionally you may use OFChallengeDefinitionService to download challenge titles and icons to use in your menu but this is not a requirement.
Allow the user to play a game session while recording the necessary data, The data recorded may be xml, binary data or anything else you'd like. It will be stored on the OpenFeint servers as a binary chunk.
Call [OFChallengeService displaySendChallengeModal]. This will allow the user to pick friends and send out the challenge.
If you wish to give the user an option to create a stronger challenge for multi attempt challenges instead of sending out the one he just created, implement userRestartedCreateChallenge in your challenge delegate.
Implement sendChallengeScreenClosed in your challenge delegate and return the user to your challenge selection menu or some other appropriate screen in it.

Playing a challenge

Implement userLaunchedChallenge in your challenge delegate. When this gets called you need to launch the appropriate game type based on the challenge definition in the passed in OFChallengeToUser (accessed through the contained challenge) and the challenge data. You must retain the OFChallengeToUser and challenge data somewhere so it may be serialized to disk if the user turns of the game. For multi attempt challenges the user may also decide to retry the challenge in which case you must have this handy.
If the user closes the game during the challenge serialize the challenge data along with any other game data. The OFChallengeToUser may be serialized by calling [OFChallengeService writeChallengeToUserToFile].
Implement userRestartedChallenge in your challenge delegate. For one shot challenges you may leave it empty. For multi attempt challenges you should start the game session over using the OFChallengeToUser and challenge data you received when the challenge was first started.
Once the game session is over call [OFChallengeService submitChallengeResult]. This should always be called, regardless of the result and what kind of challenge it is.
Call [OFChallengeService displayChallengeCompletedModal]. This will show the result of the challenge and in the case of multi attempt challenges allow the user to re-challenge (if the challenge was beaten).
Implement completedChallengeScreenClosed in your challenge delegate. Either return the user to the main menu or some other appropriate screen.

Header Files

OpenFeint.h
OpenFeint+Dashboard.h
OFChallengeService.h
OFChallengeDefinitionService.h
OFChallenge.h
OFChallengeDefinition.h
OFChallengeToUser.h
OFChallengeDelegate.h

Achievements

Wed, 25 Aug 2010 20:59:37 GMT

Overview
OpenFeint Achievements allow you to provide incentive to your players for completing alternative goals. For example, in a Hockey game, you might have an achievement for making a hat trick or winning a fight without taking any hits. When designing achievements for your title, think about what alternative objectives a player could have that require skill or effort. Achievements in OpenFeint have the following features:

An achievement is initially locked but can be unlocked one time by each player.
Each achievement awards a player with a set number of Feint points.
Each player has a Feint Score. It’s the sum of all her unlocked achievements.
A player’s Feint score is prominently displayed on her profile.
You can optionally customize the icon, name, description and score for every achievement in your game. We also provide a default icon for your achievements. Customized icons should be of size 50 x 50 pixels.
An achievement can be marked as “secret.” A secret achievement’s description and icon will be hidden from a player until he unlocks it.
Each title can have up to 100 achievements worth up to 1000 Feint score.
Achievements can be unlocked even when a player is offline.

Quick Start

Create an achievement in the Developer Dashboard.
Note its Unique Identifier.
In your application, unlock the achievement using [OFAchievementService unlockAchievement:];

Note: that you may call this unlock function more than once. It will only have an affect the first time it is unlocked for a player.

Header Files

OFAchievementService.h
OFAchievement.h

Achievements Policy

Developers cannot create applications designed solely for the purpose of generating achievement points. OpenFeint reserves the right to disable achievements for applications that fall under this category. For additional information or clarification please contact developer support.

OpenFeint Art Assets and Branding Guidelines

Thu, 19 Aug 2010 20:48:01 GMT

I. Introduction

As the premier social network for iPhone games, it’s important that players have a consistent experience using OpenFeint across games. This document lays out our preferred presentation of how OpenFeint is made accessible and presented to players within games. We’ve thought long and hard about these guidelines and know you’ll get the most out of OpenFeint by following them.

We have provided a complete asset pack in the appendix of this document with our logos for you to use. Be sure to download it and take a look.

II. Attribution

This is pretty simple, your app must conspicuously display a graphic that indicates you have services provided by OpenFeint. This can be a splash screen at the launch of the app, a small notification, or our pre-made “OpenFeint Enabled” graphic.

III. Branding

There are a few places which we need you to display the inclusion of OpenFeint in your game. Properly displaying our brand will help ensure that your customers are exposed to the social opportunities that await them.

App Store Branding:

The logo may be displayed as a watermark on the application icon. We highly encourage this!
The following text must be displayed in your app description on the iTunes app store, “[App Name] is OpenFeint Enabled.” Oh, and please be sure to change [App Name] to the name of your app.

In-App Branding:

The logo may be displayed on the application “default” screen.
If your game has a main menu, the OpenFeint logo must be displayed and look like a button. The OpenFeint dashboard must be accessible by touching it.
While someone is using your app, OpenFeint must be accessible at any time, even in the middle of a game session, this may be from a pause screen.
If your game has a pause screen, the OpenFeint leaf button must be visible on it.

IV. Don’ts

We’ve provided a library of acceptable OpenFeint logos, which can be found in the Appendix. You may not alter the colors of these graphics in any way. Any graphics which are provided on a transparent background may be placed on a background of your choosing, although the logo must be clearly visible (i.e. do not use the white logo on a white background).

V. Appendix

We have provided pre-made image files for your use, which you can find here.

iPurchase Setup

Tue, 26 Jan 2010 23:23:44 GMT

Overview

OpenFeint’s iPurchase program allows you as a developer to participate in our powerful promotion and discovery programs. Information provided within the iPurchase dashboard is featured prominently within the OpenFeint client and the new OpenFeint.com player’s site. If you don’t set up your iPurchase page, you won’t be able to take advantage off all the cross-promotional opportunities.

Where does this information show up?

At OpenFeint we are constantly looking for ways to increase game awareness and discovery. The details you provide in iPurchase currently show up in the following places. Any new additions will be added to this list.

The OpenFeint Client

OpenFeint Client Dashboard – Players who click on the OpenFeint icon within the OpenFeint 2.4 client are greeted with a number of discovery options.

Featured Banner (Landscape and Portrait Modes) – Displayed at the top of the Game Page and Discovery Page.
Featured Preview (Landscape and Portrait Modes) – Shown if your game is contained within one of the featured lists for the player.

Friends Lists – If a friend of a player owns your game, your icon will show up in the list of Games Played and link directly to your iPurchase page.

iPurchase Page – Your opportunity to speak directly to the potential player. Summarize your game, show the player screenshots, and detailed information on why they should download. This page contains a direct link to the App Store and allows the player to purchase right from their device.

OpenFeint.com

We’ve recently relaunched OpenFeint.com with new features that highlight games in our system. Adding your game’s information to the iPurchase page makes it eligible for display within the OpenFeint spotlight, Feint 5, and Game Information pages.

OpenFeint iPurchase Setup Page Help

The OpenFeint iPurchase setup page within the developer dashboard is your gateway to manage the information displayed to players. The iPurchase setup is located within the Basic Features section of your Application Home. All of the information can be updated at any time, just make sure you click on submit after making changes.

Icon – 100 x 100 icon with a maximum file size of 150kb. It’s recommended that you use the same icon that you are using in the App Store. The icon is used when displaying lists of friend’s games, within the Discovery pages, and in your iPurchase page.

USD Price – Entered as 0.99 for a 99 cent game (no dollar sign necessary). For free apps, just put in FREE and we’ll take care of the rest. Changing your price for a week? No problem, just update this field. Information stored here will be displayed within your game’s iPurchase page and on OpenFeint.com.

iTunes ID – The iTunes ID for your game. Don’t have one yet because your app isn’t approved, don’t worry, just enter 1 and update it once you’ve received Apple’s approval. It’s important that this information is correct as we use it to provide players with game information on OpenFeint.com

Category – This should match your category within the App Store and can be used by OpenFeint to better target which games are displayed to players.

Release Date – Enter as a date string Month, Day Year. Example: December 20th, 2009.

Current Version Number – The version number of the application that is currently (or will be) live in the App Store. Remember to update this field when releasing new versions!

Summary or Tagline – A short 128-character tagline to grab a player’s attention. Used within the iPurchase page of your game and on OpenFeint.com. We suggest 2 sentences max.

Extended Description – Your chance to really shine. Provide players with a detailed description of your game after scrolling past the Summary and Screenshots. This field supports HTML formatting, but note that links are disabled.

Primary Screenshot – A 320 x 480 screenshot of your game. For games in landscape mode, it still needs to be a 320 x 480 image, with the ‘top’ of your image facing right as the image will be rotated counter-clockwise when displayed in landscape mode.

Featured Banner Landscape (OpenFeint 2.4) – 464 x 42 image. The banner we’ll use for your game page and potentially at the very top of the OpenFeint client Discovery page.

Featured Preview Landscape (OpenFeint 2.4) – 150 x 49 image. We’ll use this image if your game is contained within one of the lists for the player on the Discovery page. Also, if another developer adds you to their featured app section, we’ll use this asset.

Featured Banner Portrait (OpenFeint 2.4) – 304 x 42 image. This is the image we’ll pull for your game for the top of the Discovery page if the user is in Portrait mode.

Featured Preview Portrait (OpenFeint 2.4) – 104 x 49 image. Same as above but for players in Portrait mode.

Conclusion

We hope that this has given you a solid understanding of the iPurchase setup and why you should keep it updated for all of your OpenFeint enabled games. If you have any additional questions, please contact us and we’ll be happy to help.

OpenFeint API Organization

Fri, 06 Nov 2009 00:38:20 GMT

Resources and Services

OpenFeint’s APIs are organized by resource. A resource is a single object that is interesting to a user or developer. Examples of resources in the OpenFeint SDK are achievement, high score, leaderboard, and user.

Almost every resource has a corresponding service that allows you to create, read, and update that resource or a list of that resource.

Resource Naming Conventions

All Objective-C definitions related to a resource are named after it. You can use this simple pattern for finding header files and class names for a resource:

OFResourceName and OFResourceNameService

Simply Replace ResourceName with the name of the resource you’re looking for.

Resource Example: Achievement

Using the pattern described above, it’s easy to intuit the header files and interface names for the Achievement resource:
Resource interface name: OFAchievement
Resource interface header file: OFAchievement.h
Resource service interface name: OFAchievementService
Resource service interfface header file: OFAchievementService.h

OpenFeint Unity-iPhone Support

Thu, 08 Jul 2010 01:23:31 GMT

Note, for developers experiencing issues with Unity and iOS4, please refer to this forum thread:
OpenFeint Developer Support Forum - Unity & iOS4

OpenFeint Unity support
version 2.0
build 1.15.2010

Release Notes
Copyright (c) 2009-2010 Aurora Feint Inc. All Rights Reserved.

What's new? 1.15.2010 version 2.0 - Completely rewritten Unity plugin for much easier integration and more features

This document explains how to integrate the OpenFeint-UnityiPhone package.

Below is a step by step explanation for the integration process.

1. If this is a new Unity project, make sure to set up your Player settings first (Edit->Project Settings->Player). This is required for the automation process to work properly.
2. In Unity, go to "Assets->Import Package..." and import the attached Unity package.
3. Note the new "OpenFeint" menu item in the menu bar. Click on this and go to "Set Application Initialization Settings...". In this dialog, set up all of the OpenFeint initialization settings and click Apply. This step only needs to be done once for each application. It is recommended that you turn "Allow Notifications" on.
4. If desired, copy your "openfeint_offline_config.xml" into the "Editor/OpenFeint/Offline Config File Goes Here" folder. You will need to do this every time you make a change to achievements or leaderboards through the developer dashboard.
6. For your first build with OF support (and anytime you need to do anything other than an "Append" build in Unity), make sure that the Xcode project isn't open as it causes problems. We're looking for a solution for this.
7. Go to Unity "Build Settings" (File->Build Settings...) and "Build" the project (not "Build & Run" for the first build; subsequent builds of the project can use Build & Run though).
8. Follow the instructions in the OpenFeint readme.txt file. These are steps for adding OpenFeint to your xcode project. You only need to do this once.
9. Hit "Build & Run". Your application will launch on your iPhone and the OpenFeint welcome screen will appear on your first run.
10. Use the handy methods, events, and properties located in "Plugins/OpenFeint.cs" to hook up achievements, leaderboards etc.

NOTE: If you want to build for an iPhone OS prior to 3.0 it is important that you follow the instructions in the OpenFeint readme.txt file for weak linking your libraries.

Changelog

--- 10.28.2009 - version 1.0 Improved documentation and official release

--- 9.14.2009 - version 0.9 (pre-release) Added support for achievement delegate events

--- 9.04.2009 - version 0.8 (pre-release) Initial support for showing the dashboard, submitting high scores, and unlocking achievements

The files

OpenFeint-Unity-README.txt

OpenFeint-UnityiPhone.unityPackage

Social Notifications

Thu, 02 Sep 2010 22:47:06 GMT

Overview

OpenFeint social notifications allow you to announce to a player’s friends what he is doing in your game. Social Notifications have the following features:

Sent to a player’s Facebook and/or Twitter Stream.
Must be no greater than 125 characters in length.
Are always prefixed with I or My Name.
Have an optional pre-uploaded image associated with it
Are automatically sent out when a player unlocks an achievement.
Always request permission from the player before sending.
Are referred to as “Published Game Events” in the OpenFeint Dashboard screens.

Quick Start

Simply send a notification from your application through either of the following APIs:

[OFSocialNotificationApi sendWithText:@"just gained a level", nil]; // high level api
[OFSocialNotificationService sendWithText:@"just gained a level"]; // low level api

Header Files

OFSocialNotificationApi.h (high level api, preferred)
OFSocialNotificationService.h (low level api)

These notifications keep popping up during gameplay and interrupting the player! What gives?
Since we automatically prompt the user to post a notification after an achievement is unlocked this is often the case. We are actively working on a solution to this issue (which will probably end up similar to the OFNotificationDelegate which handles the small pop-up notifications).

Sending a Text and Image Notification

Upload an image to the Facebook Notification Images section the Developer Portal.
In your application, send the notification with [OFSocialNotificationService sendWithText:@"shared the space ship with the world" imageNamed:@"ImageIdentifierName"];

What exactly will a notification say?

All social notifications are prefixed with a proper noun referring to the player. Here are some example notification texts and their final appearance on social networks:

Submitted Text: just gained a level
On Facebook: Jason just gained a level
On Twitter: I Just gained a level
Submitted Text: wandered into an open forest.
On Facebook: Jason wandered into an open forest.
On Twitter: I wandered into an open forest.
Submitted Text: saved the forest ten times today.
On Facebook: Jason saved the forest ten times today.
On Twitter: I saved the forest ten times today.

Social Notifications and Privacy

Depending upon the social network, OpenFeint uses a one or two-stage authentication process before sending a social notification on behalf of a player.

Requests extended permissions if necessary. This may require a user enter their social network username and password again.
Display the notification to the user and ask for permission to publish the notification. Users may opt to remember their selection. By default, remember is OFF.

App Approval Required For Testing

Currently OpenFeint requires that an application has requested approval and been approved before posting to social networks. See the big green "Prepare for Submission" button on the OF dev dashboard. We do this so that you don't accidentally broadcast that you are adding OpenFeint to your game before you're ready.

Using OpenFeint to upsell from Free to Paid

Tue, 22 Dec 2009 18:28:41 GMT

Overview

The following document shows how to improve conversion from free to paid version of games, by integrating OpenFeint in both the free and paid version of the app. It discusses how to limit the free version to a subset of the full leaderboards, achievements and challenges in the paid version. The same technique can be used to enable specific social gaming features only for users that have bought In-App Purchase packs.

Taking the Plunge : Registering your Game in the Dev Dashboard

The OpenFeint development dashboard is where you register your game and obtain a unique product key and secret key to initialize the OpenFeint libraries. You should only register one game with OpenFeint, even though you will have two versions of it: one free and one paid. Using the same OF registration for both the free and paid version of your game means that users will be able to start playing the free version, earning achievements, submitting high scores, while still having a clear migration path to the paid version.

By using the same product and secret keys from the dev dashboard in both versions, the paid-only leaderboards and achievements will be listed in the free version, and will help show there is added value in the paid version. Paid and free version owners will be able to chat and engage in forums with each other, where the paid version owners can help promote your game to those using the free version. Free and paid version owners will also be able to compare scores and achievements, highlighting the fact that paid owners will have scores submitted to leaderboards and earned achievements the free version owners can't have without upgrading.

Another benefit of using a single registered OpenFeint game for both the free and paid version is the in-dashboard promotion of games available with OpenFeint. By filling the iPurchase info for their paid game in the dev dashboard, both free players and paid players will be helping promote the game to their friends through the developer dashboard and taking prospective buyers to the paid version of the game in iTunes. The developer should also create Featured banners and icons for the new in-dashboard promotional tools in OpenFeint 2.4. These banners should target free version players, enticing them to upgrade.

The Key is Careful Design

During design of your game, you should carefully decide which features of your game are going to be unique to the full paid version, and which features will be made available in the free version.

For example, you could release the paid version with 15 to 20 or more levels, and restrict your free version to between 5 and 8 levels. Adjust this depending on how many levels your paid game has. A puzzle game with a hundred levels in the paid version could release a free version with 20 levels. Splitting your levels like this means that when creating leaderboards in the dev dashboard, those leaderboards that are only available in the paid version should indicate so in their titles. If you are using In-App Purchase in your game, you should also indicate which leaderboards are only available to players that have bought your In-App Purchase packs.

You should also think of how you are going to distribute achievements throughout your game. The name and description for the achievement should explicitly indicate if they are available in the paid version only.

Careful naming of leaderboards and achievements to indicate which are available only in the paid version will help drive sales among free users. When navigating the OpenFeint dashboard for your game, the paid-only leaderboards and achievements will be listed in the free version, and will help show there is added value in the paid version.

An example of how this is handled is the game Gravity Sling by Riptide Games. The free game comes with 19 levels, and has several In-App Purchase packs with 30 extra levels each. The free version shows leaderboards and achievements for each level in the In-App Purchase Packs in the OpenFeint Dashboard. This shows players how much value there is in the In-App Purchase packs, and is a great upsell incentive.

Coding Best Practices for Easy Free to Paid Upgrades

After you have designed your game and how you are going to divide levels, leaderboards, achievements, etc. between your free and paid versions, then comes the job of coding your game. Here are some practices for organizing your code so that you can limit the free version to a subset of all of your game's features.

Use Conditional Compilation in Free to Paid Games

With conditional compilation, you as developer set up portions of your code that only run if a flag is passed to the compiler. If the flag is not set, that segment of code will not be compiled into your game. You can use this to limit game progression in the free version, by locking out levels, leaderboards and achievements.

One way to set up conditional compilation in your XCode project, is to create build settings for each version of your app. Open your project in XCode, then either right-click on the project icon (the blue icon at the top of the "Groups and Files" pane) and select "Get Info" or click on the "Project" menu and select the "Edit Project Settings" option.

This will open the Build settings window. Select the "Configurations" tab. Every project in XCode comes with "Debug", "Release" and "Distribution" configurations set with some useful default values.

By selecting a configuration name and clicking on the "Duplicate" button, you create a new configuration that is a replica all the settings of the selected configuration. For example, selecting the "Debug" configuration and clicking on "Duplicate" creates a new configuration called "Debug copy". This "Debug copy" has the same settings as configuration "Debug". By creating a copy we can change the settings in the copy without affecting the settings of the original.

Rename "Debug copy" to "Debug Free". Duplicate the "Release" and "Distribution" configurations and rename them, so that in the end you have "Release Free" and "Distribution Free" configurations created.

Once you have created "Debug Free", "Release Free" and "Distribution Free" configurations, click on the "Build" tab and select "Debug Free" in the "Configuration:" drop-down list. Type "preprocessor" in the search field next to the "Configuration:" drop-down list, then look for "Preprocessor Macros" or "GCC_PREPROCESSOR_DEFINITIONS" in the settings below.

Once you find this setting, add "__IS_FREE_GAME__" to whatever other value you find for this setting. That is, don't destroy any values that are set. Just add "__IS_FREE_GAME__"at the end of the setting. In the example shown above, the value "_DEBUG" was already set for this setting. "__IS_FREE_GAME__" has been added at the end. Don't forget to set the same "__IS_FREE_GAME__" value for this setting in the "Release Free" and "Distribution Free" configurations.

Now that we have set the "__IS_FREE_GAME__" preprocessor definition, we can detect it in our game's code with #ifdef __IS_FREE_GAME__

The sample code below limits submitting high scores in one leaderboard in the code for the paid version only.

#ifdef __IS_FREE_GAME__

// do not submit a high score in leaderboard ID 12345 for free version

#else

[OFHighScoreService setHighScore: score forLeaderboard: @"12345" onSuccess: OFDelegate() onFailure: OFDelegate()];

#end

The sample code below limits unlocking a specific achievement.

#ifdef __IS_FREE_GAME__

// do not unlock achievement ID 5678 for free version

#else

[OFAchievementService unlockAchievement: @"5678" onSuccess: OFDelegate() onFailure: OFDelegate()];

#end

Check In-App Purchase Receipts in Free In-App Purchase Games

If you are using In-App Purchase in your game, the code above is not what you should use. A simple way to integrate In-App Purchase into your app, besides the relevant In-App Purchase API calls, is to save a User Default in your code for each In-App Purchase pack the user has bought. This way, you can use simple code to check whether the user has bought an item, as shown below.

NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];

BOOL feature1Purchased = [userDefaults boolForKey: in_app_purchase_feature_1];

if (feature1Purchased)

{

[OFHighScoreService setHighScore: score forLeaderboard: @"12345" onSuccess: OFDelegate() onFailure: OFDelegate()];

}

else

{

// do not set high score for leaderboard ID 12345 for user without In-App Purchase pack "feature 1"

}

In the code above, in_app_purchae_feature_1 is a constant used to identify the In-App Purchase feature in your user defaults and other places in your code. This could be the product identifier you use in the App Store API to identify each separate product. In your In-App Purchase code, when the user payment has been approved, save the key to User Defaults like this:

NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];

[userDefaults setBool: YES forKey: in_app_purchase_feature_1];

Note: in your In-App Purchase implementation, remember to provide a way for users to restore previously unlocked levels when they remove and reinstall your app, or when they upgrade to a new device. You can either do this at game start up before you display the main menu, or provide a button for users in your UI. The IAP SDK provides the method - (void)restoreCompletedTransactions in the SKPaymentQueue class for this purpose. The specifics of a proper IAP integration are beyond the scope of this document. Refer to Apple's In App Purchase Programming Guide for reference.

Upselling the Paid Version in the Free Version

Besides limiting high score submissions and limiting unlocking achievements in the free version of your game, you can present the user with messaging to upsell your paid version within your game. You could give the player a demo of one of your paid levels and instead of submitting their high scores at the end of the demo level, or unlocking any achievements they may have earned, you can present them with a message informing them of the benefits of the paid version of the game. The code is similar to what's been presented above, but instead of doing nothing when the user has the free version, the sample code below presents an alert view.

#ifdef __IS_FREE_GAME__

[[[[UIAlertView alloc] initWithTitle:@"Feature unavailable in free version" message:@"The achievement 5678 is only available for owners of the paid version. Please buy it. I iz poor!" delegate:nil cancelButtonTitle:@"Ok" otherButtonTitles:nil] autorelease] show];

#else

[OFAchievementService unlockAchievement: @"5678" onSuccess: OFDelegate() onFailure: OFDelegate()];

#end

You may prefer to push a whole different screen to the user, with graphics, screenshots, and a buy button for your app. You definitely want to come up with more effective messaging than what is presented in the code sample.

Presenting appropriate messaging is important specially if your paid game features challenges. If you use the same OF client application in your free version as your paid version, or if you use In-App Purchase, there is a possibility a paid user could send a challenge to a friend with the free version of the app.

Test Users

Mon, 30 Aug 2010 23:42:07 GMT

Overview

The OpenFeint Developer Dashboard now contains a "Test Users" section. "Test Users" is a development tool that lets you reset a users achievements and high scores from within the developer dashboard. You can also unlink a user's facebook/twitter account, or remove a user from a device.

Quick Start

You can make an existing OpenFeint user a test user by going to the test users tab and entering the email address & password associated with that account (test users must have been 'secured'). Developer accounts may not be turned into test users for safety reasons.

Once you've added a test user you can reset the user's achievements and leaderboards by clicking on the game name, then selecting an individual high score or unlocked achievement to delete, or clicking "delete all" to delete them all.

You can also unlink a user's facebook/twitter account, or remove a user from a device. To remove a user from a device, find the device by it's Apple UDID in the credentials list, and click delete. Then, remove the application from your device and reinstall it. When you launch the application again, you will be presented with the initial OpenFeint welcome/approval screen. Note that if you don't remove the application from the device and simply close and relaunch the app, a new user will automatically be created, but you won't see the welcome/approval screen.

You may find a free service such as spamgourmet.com useful for generating additional email identities to uniquely secure each test user account.

Known Issues

Removing test user data from the server via the OF dev dashboard will not remove corresponding data from the client side offline data cache. To purge all client side data and prevent it from being resynchronized with the server it is necessary to remove the app itself from the device or simulator.

Developer accounts may not be turned into test users. When you enter a developer e-mail and attempt to turn the user into a test user, the message may incorrectly report that it succeeded.

OpenFeint Gold Requirements

Tue, 02 Mar 2010 19:25:27 GMT

What is OpenFeint Gold?

OpenFeint Gold is recognition given to the best combinations of fun gameplay and complete OpenFeint integration.
To be considered for Gold status, your game must meet some minimum integration requirements, outlined below. If you feel your game is Gold material, you can submit it for consideration here. OpenFeint will select Gold games based on quality of gameplay, production values and depth of integration.
If your game is awarded Gold status, you’ll benefit from advertising and support aimed at pushing your work to the top of the sales charts.

Requirements

A successful OpenFeint integration enhances the fun and replay value of your games. Using OpenFeint, you can easily add modern social gaming features to your game, including Leaderboards, Achievements and Challenges.

OpenFeint allows deep customization. As you consider how you’ll use OpenFeint, strive to blend each OpenFeint feature into your interface and gameplay. Ideal integrations allow the player to benefit from OpenFeint without having to leave your game.

Leaderboards

Leaderboards provide a global means of tracking player scores. Players can see their scores on a global list or see rankings against just their friends.

Usage

OpenFeint APIs provide you with leaderboard data which you can use to drive custom interfaces. Your high score UI should match your game’s overall look and feel, maximizing the player’s immersion in your game’s experience.

Ideas

If your game is level-based, display a leaderboard after the player completes a level. Don’t want to show the whole leaderboard? You could also show the player’s friend rank.

If your game features fast, continuous action, consider integrating the leaderboard by displaying the player’s current global rank during gameplay along with your game’s next-highest score. This adds challenge and excitement for players as they watch themselves soaring up (or down) the charts.

You can stoke your player’s competitive fire by displaying current friend high scores on your game’s main menu. Highlight the player’s score and each time he launches your game, he’s able to see the score to beat, setting gameplay goals accordingly.

Leaderboards can also be accessible through your main menu. Curious players will know the latest scores are only a few taps away.

Examples

Solitaire Tri Towers displays inline leaderboard data.

Fieldrunners displays high scores in a custom view, available both through the game’s menu and displayed after a game is completed.

Hook Champ sports a heavily customized leaderboard view.

Achievements

Achievements provide recognition for in-game player accomplishments. Games can present a blend of achievements, ranging from the mundane (ten kills with a sniper rifle) to the nearly-impossible (finish the game with 100% health). By encouraging players to collect achievements, you improve replay value of your game.

Usage

OpenFeint APIs provide achievement data you can display in your games. Finding ways to integrate and acknowledge these achievements without requiring the player to leave your game is important. While players enjoy the accomplishment of unlocking an achievement, they don’t want that to come at the cost of interrupting their experience.

Ideas

When a player unlocks an achievement, immediately display a notification that matches your game’s look and feel while

For level based games, display a listing of completed achievements at the conclusion of each level.

Similar to leaderboards, you can allow players to access a view of their achievements through your game’s main menu. Your game can display a list of achievements using a list interface that matches the rest of the game experience.

You could also entice players by displaying a progress bar on your main menu showing how close they are to 100% achievement completion.

Examples

Fieldrunners provides a view of achievements that matches the game’s look and feel. This view is accessible through the game’s main menu.

Must Eat Birds breaks away from listing achievements altogether, displaying them instead like a rack of pastries, consistent with the game’s theme.

Player Data and Communications

OpenFeint’s social underpinnings provide significant, turn-key solutions for any game with social components.

Usage

OpenFeint’s API exposes powerful features you can use to provide both real-time and asynchronous communication among your game’s players. You can also access profile data, using it as a starting point for getting to know the player better.

Ideas

If having the player’s photo will let you enhance gameplay, consider capturing their OpenFeint profile image.

Expose the Fan Club directly on your main menu to your players. Encourage them to opt-in for your newsletter or favorite the game so their friends can see what they’re playing.

Challenges and Multiplayer

Social interaction through challenges and multiplayer gaming can take your product to a new level of engagement and value. These features should be exposed in your main menu, increasing the gameplay options your players can enjoy.

Usage and Value

Challenges are an asynchronous method to play against friends. After concluding gameplay, players can challenge their friends to beat their performance.

Examples

Arithmetic Master lets users begin a challenge once they’ve completed some gameplay.

Multiplayer

Multiplayer is a feature of OpenFeint currently in private beta. Invitations to this beta are extended based on game quality. Contact us if you believe your game merits consideration.

General Integration Practices

OpenFeint should initialize at startup. This allows your game to log players immediately into OpenFeint or prompt them to create an account, as needed. As all other elements of the OpenFeint experience, you can create a custom start screen that matches your game’s look and feel.

Steampunk Hockey features a custom start screen that matches the rest of the game’s interface.

The OpenFeint logo should appear in your game’s icon. Players look for this logo in when expanding their library. Piyo Blocks includes the OpenFeint logo in its icon.

Notifications

OpenFeint’s drop-down notifications are customizable. The best integrations will create notification UI that keeps players in touch with their OpenFeint account while still maintaining the game’s overall flavor.

Branding and Dashboard

The OpenFeint dashboard should be accessible either from your game’s main screen or pause screen using OpenFeint branding. Players expect easy access to the dashboard across all their games. Honoring this expectation provides the best possible experience for your players. Customizing the OpenFeint art to fit your game’s interface is encouraged so long as you comply with the platform’s branding guidelines.

When OpenFeint data drives integrated leaderboards, achievements or challenges, brand those elements of your interface using the leaf logo.

Jet Car Stunts gives Jakob a standard OpenFeint notification that matches the rest of the game’s menu interface. Since OpenFeint drives its challenge system, detailed on the top-right of the menu, a leaf logo is present. A button to access the OF dashboard is also prominent. The leaf logo has been styled to match the menu’s ultra-modern look.

Bird Strike integrates the OpenFeint logo with its OF-driven Leaderboards in its menu interface.

Hook Champ displays the OpenFeint logo styled according to its 8-bit design motif, presenting easy access to the dashboard from the game’s main menu.

Push Notifications

Fri, 06 Nov 2009 00:18:20 GMT

Overview
Challenges use push notifications to notify users when they have been challenged. Push notifications are supported on all devices with OS 3.0 and up. In order to support push notifications your game must build against base SDK 3.0 or newer, but you may use a lower deployment target allowing your game to still work on OS 2.x devices. OpenFeint handles all the server work and communications with apple. You only need to supply us with your certificate and add a few lines of client code.

When a user sends out a challenge he may type in a message. This message along with the application name is what will appear in the push notification. The default message is "Try to beat me!".

Quick Start
Setting up the certificates

Visit http://developer.apple.com/iphone/. Log in to your account and go to the iPhone Developer Program Portal. Select App Ids, select configure on the app you want to enable and follow the instructions for getting a push notification certificate. Not that you may not use wildcard provisioning profiles with push notifications and you will need one certificate for development and one for distribution.
Once you've downloaded the certificates, install them on your local machine. Open the Keychain Access application and export the certificates in .p12 format. When exporting don't use your regular password as you will need to supply it to the OpenFeint dashboard. If you are exporting and the .p12 format is not selectable (greyed out) then please make sure you have selected 'Certificates' in the category window of Keychain Access.
Upload the certificates to OpenFeint through the Push Notifications tab on the dashboard.
Download your provisioning profile again. They need to be re-installed now that they support push notifications. Make sure to remove the old version before installing the new one.

Add the following code to your app delegate:

- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken
{
    [OpenFeint applicationDidRegisterForRemoteNotificationsWithDeviceToken:deviceToken];
}

- (void)application:(UIApplication *)application didFailToRegisterForRemoteNotificationsWithError:(NSError *)error
{
    OFLog([NSString stringWithFormat:@"Failed to register for remote notifications with error: %@", [error localizedDescription]]);
    [OpenFeint applicationDidFailToRegisterForRemoteNotifications];
}

- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo
{
    [OpenFeint applicationDidReceiveRemoteNotification:userInfo];
}

You will also need to implement application:didFinishLaunchingWithOptions and pass in the options to OpenFeint. To keep supporting older OS versions, it's recommended to do it like this:

- (void)applicationDidFinishLaunching:(UIApplication *)application
{
    [self commonInit];
}

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    [self commonInit];
    [OpenFeint respondToApplicationLaunchOptions:launchOptions];
    return YES;
}

OpenFeint uses the _DISTRIBUTION define to determine whether to use the sandbox or production environment. This is VERY important since Apple doesn't let you use the production environment with a debug build or sandbox environment with a distribution build (the one you send to Apple).
To define _DISTRIBUTION, open your project settings, select the distribution configuration (make sure to not to this for all configurations) go to "PreProcessor Macros" and add a line with _DISTRIBUTION.

Verify that OpenFeintSettingEnablePushNotifications is set to [NSNumber numberWithBool:YES] when initializing OpenFeint.

Network Save Card

Sat, 19 Dec 2009 06:56:19 GMT

About Network Save Card

The OpenFeint Network Save Card service provides a simple API that enables an application to save a blob of data to the server and retrieve it later. Each blob is associated with a specific application, a specific user, and a key name chosen by the application. An application can only access blobs that it has created and only those that are associated with the current user. OpenFeint Network Save Card can be thought of as simple flat file system that follows a user account around the network and restores application specific data to a game even if the account shows up on a different device.

Network Save Card is a new service available as of version 2.4 of the OpenFeint SDK. The service is only available when OpenFeint is in the online state. An application is allowed to consume up to 256K of cloud storage per OpenFeint user account. Warning: accounts exceeding the limit may find that excess blocks are initially granted then mysteriously disappear from the server a week later. If your particular game has a good reason to consume more storage, please send us a support request explaining your needs and we'll see what we can do to increase your limits so that you do not experience disappearing data.

Use Case: Save Game State

One typical use case for the Network Save Card is to save the current player's game state. For games that allow a branched path through through the game, it is possible to save multiple game states under one OpenFeint identity provided that particular user's overall storage limit for that game is not exceeded.

Data Blob Access Methods

The API consists of two simple methods: one for uploading and one for downloading. Each blob is distinguished by a key name unique within the context of the current application and user. The blob of data itself is passed through the API as an NSData object consisting of whatever binary data the application may store. The prototypes of the two methods are:

 
+ (void)uploadBlob:(NSData*) blob withKey:(NSString*) keyStr
    onSuccess:(const OFDelegate&)onSuccess onFailure:(const OFDelegate&)onFailure;
+ (void)downloadBlobWithKey:(NSString*) keyStr
    onSuccess:(const OFDelegate&)onSuccess onFailure:(const OFDelegate&)onFailure;

The key string is case sensitive alphanumeric text that must begin with an alphabetic character. The dash and underscore characters may also be used in this string. Key strings may be up to 32 characters long. The result of using a longer string is undefined. The last two parameters of each method accept application defined OFDelegate style callbacks to be executed upon success or failure of each API method.

Using Network Save Card

The sample app included with the API gives a simple demonstration of cloud storage in use. Try running the sample app and confirm that you can send and receive a couple of test blobs with different key strings. Take a look at the source code for this sample in the files "CloudStorageDemoController.mm" and "CloudStorageDemoController.xib".

The first thing to do in your own code is to include the appropriate header:

 
#import "OFCloudStorageService.h"

Next, make sure you can send a blob of data and see that your success delegate is called.

 
- (IBAction)onBlobSend:(id)sender{
    NSData      *payloadData =
        [blobPayloadTextBox.text dataUsingEncoding: NSUTF8StringEncoding];
    OFDelegate   successDelegate(self, @selector(blobSend_SuccessDelegate));
    OFDelegate   failureDelegate(self, @selector(blobSend_FailureDelegate));
 
    [OFCloudStorageService uploadBlob: payloadData
        withKey: blobNameTextBox.text
        onSuccess: successDelegate
        onFailure: failureDelegate
    ];
}

You can define the success and failure delegates very simply to start out. They don't have to do anything yet. You just need them as a place to intercept a breakpoint or spit out an NSLog string to see when they get called. Each should have a void return value and no parameters. The blob you send can be a simple chunk of text for now but you will be able to substitute this later with any binary data you like.

Next, try fetching a previously submitted blob using the key values you created them with.

 
- (IBAction)onBlobFetch:(id)sender{
    OFDelegate successDelegate(self, @selector(blobFetch_SuccessDelegate:));
    OFDelegate failureDelegate(self, @selector(blobFetch_FailureDelegate));
 
    [OFCloudStorageService downloadBlobWithKey: blobNameTextBox.text
        onSuccess: successDelegate
        onFailure: failureDelegate
    ];
}

Note the colon at the end of the success delegate name in this case. This delegate receives one parameter containing the data fetched from the server. The failure delegate has no parameters or return value just like the result delegates used when sending a blob. See the following example and note that you could intercept a breakpoint to confirm that receivedString has the content you were expecting.

 
- (void)blobFetch_SuccessDelegate:(NSData*)blob{
    NSString        *receivedString = nil;
    NSUInteger   blobLen    = [blob length];
 
    if (blobLen <= 0){
        receivedString = @"";
    }else{
        receivedString =
            [[NSString alloc] initWithData: blob encoding: NSUTF8StringEncoding];
        [receivedString autorelease];
    }
}

Once this sample is clear there should be no trouble extrapolating this service to handle whatever type of data you need to store provided that it meets the storage limitations.

Offline Support

Fri, 06 Nov 2009 00:20:56 GMT

OpenFeint version 2.2 has high score support for users that do not agree to join the OpenFeint community.

Define all the leaderboards for your application.
Go to the Offline section in the developer dashboard, and click Download
Add the downloaded file openfeint_offline_config.xml into your project.

Anytime you modify your leaderboard definitions you must download a new configuration file to get the changes.

If the user does agree to join the OpenFeint community, when a score is submitted or an achievement is unlocked while offline it is stored on their device and the next time they play online these will be sent to the OpenFeint server automatically.

When offline they can also view their achievements and/or top 10 personal high scores.
Achievements and latest high score reached while playing on another device are sent to current device they are playing on.

Changes to leaderboard or achievement definitions are automatically synchronized to the device.

Approval Screen Overview

Thu, 05 Nov 2009 23:53:41 GMT

What is it?

As of OpenFeint version 1.7 we've included what we call the 'Approval' screen. This is the first screen a user sees before any interaction with OpenFeint is possible, and asks the user if they would like to use OpenFeint or not. If the user chooses to use OpenFeint then a brief account creation / identification flow begins.

Why do we have it?

Apple requires that we notify the user that we will be submitting their score, achievement, etc... data for storage on our servers. In general, we also want the user to know what OpenFeint is and how it will enhance their experience!

Customization

Can I customize this screen?
Yes. OpenFeint allows a developer to easily customize the initial approval screen.

What do I need to do to customize the approval screen?
Developers must provide OpenFeint with an OpenFeintDelegate during initialization. The OpenFeintDelegate must implement the following method:
- (BOOL)showCustomOpenFeintApprovalScreen;

This method should display the custom approval screen and return YES to prevent OpenFeint from displaying the default approval screen.

In addition, when the custom approval screen is dismissed (either with a YES or NO answer) the developer must invoke:
[OpenFeint userDidApproveFeint:YES/NO];

This will flag the user as having approved/denied OpenFeint and present the account creation / identification screen if required. After this flow is completed the user will then be allowed to use OpenFeint from within your application.

How can I test this screen if it only shows up once?
As of OpenFeint version 2.1 this screen will be displayed upon every installation of the application. This means that as a developer all you have to do is explicitly delete the application from your device / simulator in order to view the screen again.

Changelog

Fri, 06 Nov 2009 00:55:44 GMT

What's New - 2.3 (10.30.2009)

Multiple Accounts Per Device
- Multiple OpenFeint accounts may be attached to a single device.
- When starting a new game, user may choose which user to log in as if there are multiple users attached to his device
- When user switches account from the settings tab, he will be presented with a list of accounts tied to the device if there is more than one
Facebook/Twitter may be tied to more than one account
- User will no longer get an error message when trying to attach Facebook/Twitter to an account if that Facebook/Twitter account has already been use by OpenFeint.
Select Profile Picture Functionality
- User may from the settings tab choose profile picture between Facebook, Twitter and the standard OpenFeint profile picture.
Remove Account From Device
- User may completely remove the account from the current device if he wants to sell his device etc.
Create New User
- From the OpenFeint intro flow or the Switch User screen, the user may choose to create a new OpenFeint account.
Log Out
- User may from the settings tab log out of OpenFeint for the current game. When logged out OpenFeint will act as if you said no to OpenFeint in the first place and not make any server calls.
Remove Facebook/Twitter
- Option on the settings tab to disconnect facebook or twitter from the current account

Version History

Version 9.29.2009 (2.2)

Game Profile Pages accessible for any game from any game. Game Profile Page allows you to:
- View Leaderboards
- View Achievements
- View Challenges
- Find out which of your friends are playing
User Comparison. Tap 'Compare with a Friend' to see how you stack up against your OpenFeint friends!
- Browsing into a game profile page through another user's profile will default to comparing against that user.
- Game Profile page comparison shows a breakdown of the results for achievements, leaderboards and challenges
- Achievements page shows unlocked achievements for each user
- Challenges page shows pending challenges between the two users, number of won challenges/ties for each user and challenge history between the two users.
- Leaderboards page shows the result for each user for each leaderboard
Unregistered user support. Now you can let OpenFeint manage all of your high score data!
- Users that opt-out of OpenFeint can still open the dashboard and view their local high scores.
- When the user signs up for OpenFeint any previous scores gets attributed to the new user.
- This REQUIRES that you download an offline configuration XML file and add it to your project. This file is downloadable in the developer dashboard under the 'Offline' section. See http://help.openfeint.com/faqs/guides-2/offline for more information.
Improved offline support.
- More obvious when a user is using OpenFeint in offline mode.
- User no longer need to be online once for offline leaderboards to work.
Improved friends list. *Friends list now shows all friends in a alphabetical list.

Version 9.09.2009 (2.1.2)

Fixed an issue with OpenFeint not initializing properly when user says no to push notifications

Version 8.28.2009 (2.1.1)

Fix compiling issues with Snow Leopard XCode 3.2

Version 8.13.2009 (2.1)

Social Challenges using Push Notifications!
- Users can play a game session defined by you and challenge their OpenFeint friends to do better!
- Friends will receive push notifications (for OS3.0+) as well as notification in the dashboard
Players can now add/remove friends directly from within OpenFeint
Complete UI overhaul
Fleshed out offline support
- Support for offline high-score tables
- Support for offline achievement unlocking
- Users can view their achievements and high score data while offline
- Offline resources are synchronized with OpenFeint when online services are available
OpenFeint now uses Apache 2.0 license

Version 7.22.2009 (2.0e)

Added displayText option to highscores. If set this is displayed instead of the score (score is still used for sorting)
Removed status bar in the dashboard
Fixed bug with showing a few black frames when opening the OpenFeint dashboard form an OpenGL game

Version 7.13.2009 (2.0d)

Improved OpenFeint "Introduction flow"
User may set their name when first getting an account
User may at any time import friends from Twitter or Facebook
Nicer landing page in the dashboard encouraging you to import friends until you have some
Fixed compatibility issues with using the 3.0 base sdk and 2.x deployment targets

Version 6.29.2009 (2.0)

Friends:
A player can import friends from twitter and facebook:
A player can see all of his or her friends in one place:
Feint Library:
A player can see all the games they've played in once place
Social Player Profiles:
A player can see the name and avatar of the profile owner:
A player can see all the games the profile owner has played:
A player can see all the friends the profile owner has:
Achievements:
A developer can add up to 100 achievements to a game:
Each player has a gamerscore and earns points when unlocking achievements:
Achievements can be compared between friends for a particular game:
If you do not have any achievements to be compared, there is an iPromote Page link with a call to action prominantly visible
Achievements can be unlocked by the game client when on or offline:
Achievements unlocked offline are syncronized when next online:
Friend Leaderboards:
A leaderboard can be sorted by friends:
Player avatars are visible on the leaderboard:
Chat Room:
Each chat message has a player's profile avatar next to it:
Each chat message has some kind of visual representation of the game they are using:
Clicking on a person's chat message takes you to their profile:
Chat Room Moderation:
A player report can optionally include a reason:
A player can click "report this user" on a player's profile:
A developer can give Moderator privileges to up to 5 users from the dashboard:
When a player has been flagged more than a certain number of times, they are not allowed to chat for a relative amount of time:
Moderators reporting a user immediately flags them:
Fixed iPhone SDK 3.0 compatibility issues
Lots of bugfixes
Lots of user interface changes
Lots of Perforamnce improvements
Fixed compatibility with iPod Music Picker
Fixed glitch visual glitch in landscape when running on a 2.0 device and building with the 3.0 SDK

Version 5.29.2009 (1.7)

Simplified account setup
Users can access OpenFeint without setting up an account
Login is only required once per device instead of per app
3.0 compatibility fixes
Various bug fixes

Version 5.22.2009 (1.7)

Simplified account setup
Users can access OpenFeint without setting up an account
Login is only required once per device instead of per app
3.0 compatibility fixes
Various bug fixes

Version 5.13.2009 (1.6b)

OpenFeint works properly on 3.0 devices.

Version 4.29.2009 (1.6)

Dashboard now supports landscape (interface orientation is a setting when initializing OF).
OpenFeint can now be compiled against any iPhone SDK version
Various minor bug-fixes

Version 4.21.2009 (1.5)

One Touch iPromote
Keyboard can now be toggled in the chat rooms
Greatly improved performance and memory usage of chat rooms
Profanity Filter is now even more clean.
Massive scale improvements
Improved internal analytics for tracking OF usage
User conversion rate tracking (view, buy, return)
Various minor bug-fixes

Version 3.26.2009 (1.0)

Users can login with their Facebook accounts (using FBConnect)
Every user now has proper account "settings"
Global "publishing" permissions are now present on account creation screens
Chat scrolling now works properly in 2.0, 2.1, 2.2, and 2.2.1.
DashboardDidAppear delegate implemented by request

Version 3.20.2009

Users can login with other account containers (twitter)
Added global, developer, and game lobbies
Developer and game rooms can be configured from developer website
Account error handling improved
Polling system improvements: remote throttling, disabled when device locks
Improved versioning support
Leaderboard values can be 64 bit integers (requested feature!)
Removed profile screens
Added Settings tab with Logout button
Final tab organization and art integration
Lots of minor bug fixes and tweaks

Version 3.15.2009

Out of dashboard background notifications
Multiple leaderboards for each title (configurable via web site)
Landscape keyboard issue addressed
Startup time significantly reduced
Multi-threaded API calls now work properly
Added profanity filter to server
Basic request based version tracking
Now using HTTPS for all data communication

Version 3.10.2009

Robust connectivity and server error handling
Integration protocol no longer requires all callbacks
Various Bugfixes

Version 3.6.2009

Each game has a dedicated chat room
First implementation of background alerts
Framework preparation for future features
Framework enhancements for table views

Version 3.3.2009

First pass at Leaderboards ("Global" and "Near You")
Tabbed Dashboard with temporary icons
OFHighScore API for setting high score
OpenFeintDelegate now works
OpenFeint api changed to allow a per-dashboard delegate
Automatically prompt to setup account before submitting requests
Placeholder in-game alerts
Better offline and error support
Smaller library size (AuroraLib has been mostly removed)

Version 2.25.2009

First draft public API
Placeholder profile
Placeholder Dashboard
Account create, login, and logout

OpenFeint 2.4 Integration Changes

Sat, 19 Dec 2009 18:32:00 GMT

OpenFeintSettingDisableChat has been removed

Instead use OpenFeintSettingDisableUserGeneratedContent

Some new library dependencies have been added

CFNetwork
CoreLocation
MapKit (if building with SDK 3.0 or newer)

Automatically posting to facebook and twitter when unlocking an achievement is turned off by default.

Set OpenFeintSettingPromptToPostAchievementUnlock to true to enable automatic posting of social notifications.

Versioning

Fri, 06 Nov 2009 00:28:34 GMT

Overview

OpenFeint supports the concept of versioning OpenFeint resources based on an application’s Bundle Version. You can use this to create new resources on the server and not show them to users of older versions of your application. This is useful when developing an update to an already released application. You can then add new leaderbords, etc, that aren't visible in the previously released version but only in your new version.

The following resources can be versioned:

Leaderboards
Achievements
Chat Rooms
Challenges

Quick Start

Versions are managed through the version tab in the developer dash board. A min version and a max version have already been created. Min version appears in all applications, max version appear in no applications.

When developing a new release that needs to be versioned create a new version for it in the versions tab and name it appropriately. The version number should match the bundle version of your release.

For any new achievements etc. belonging to this release set their start version to the version of the release and end version to max version. Start and end version are set when creating a new achievement, leaderboard etc. These resources will now only appear in your new release.

Always set your currently released version to be the default version. When people look at your achievements etc. from another game they will only see resources visible to the default version of your application. This prevents people from seeing any of your resources in development while exploring in OpenFeint.

Known Issues
When editing an existing resource the version drop downs always say min and max. This is a bug when initializing the drop downs. Setting them to the correct versions before saving works and the resource is versioned properly.

We will get in a fix asap!

Featured Apps

Fri, 18 Dec 2009 01:40:42 GMT

Overview

OpenFeint’s Featured Apps allows you as a developer to promote paid versions or other titles to the player. You can populate the list with applications you’ve created yourself or highlight those of other developers. Featured Apps appear to the player in the OpenFeint Discovery Page under “Featured Games” and “More Games”.

Setting Up Featured Apps

In order to use Featured Apps, you must first have an iPurchase page set up for each game you would like to feature.

In the developer dashboard, click on “Featured Apps” in the Promotional Tools section, then click “Add New Featured App”. This will take you to a page where you can either select one of your existing games or enter the Client Application ID if the application you’d like to feature.

How do I find someone's Client Application ID?

You can only get this information directly from the other developer. We encourage developers to contact one another when featuring applications, however to make it easier you can also disclose your application ID publicly so that other developers can feature your game in their lists.

How do I find my own Client Application ID?

Make sure you’re working on the correct game and click on “App Home” in the Developer Dashboard. In the description you’ll see a field called “Client Application ID”. This is your unique identifier within our system for that application and the number you want to share if another developer would like to feature your game.

OpenFeint 2.5 - Introduction

Tue, 06 Jul 2010 23:31:38 GMT

What’s New

OpenFeint 2.5 adds a new, easier to use API for most of OpenFeint’s features. The old API is still there too making it easy to upgrade without having to change how existing apps use OpenFeint. Check out some examples of cool things you can do here.

Basic Integration

The basic steps to integrate and initialize OpenFeint are unchanged. For a quick start, refer to the “ReadMe.txt” file included in the SDK download package. More information is also available in the OpenFeint online knowledge-base.

Getting A Feel For The New API

One way to get a feel for the new API is to walk through a tutorial that makes use of one basic feature. The following tutorial shows how to unlock an achievement in a game using the new API:

Unlock Achievement

Another great way to get familiar with the API is to build the sample app that comes with the OpenFeint SDK, look at its source code, trace it in the debugger, experiment with your own changes, and cut and paste the sample code into your own game. Note that to build the sample app you will have to paste your own product key into the sample code and add your own offline config file from your developer dashboard account.

Feature Categories

OpenFeint 2.5 is divided into six categories of improved API’s and two categories of entirely new features:

User & App Info -- provides the means for developers to get basic information about the current user, other known users, who their friends are, the last games they’ve played, and information about featured games associated with the current app.
Communicating With Users -- provides the means for sending social notifications, retrieving announcements addressed to users, and giving users an easy way to invite their friends to try a game.
Achievements -- provides the means to unlock achievements and query information about specific achievements associated with the current app.
Leaderboards -- provides the means to submit high scores to leaderboards and query information about leaderboards associated with the current app.
Challenges -- provides the means for a player to challenge a friend to a game and compare their performances.
Cloud Storage -- provides the means to store arbitrary “save game” data on OpenFeint servers on behalf of the current user and game.
New Multiplayer Support -- provides match-up and turn based multi-player support.
New RESTful Web Services -- provides developers with the means to post leaderboard data on their own web sites outside of the game.

Click on each category for more details. Each category of features is implemented by one or more code modules corresponding to individual header files. Class methods and properties are further documented in the header files.

Chat Room Moderation

Fri, 06 Nov 2009 00:26:27 GMT

OpenFeint also allows developers to appoint chat room moderators. From the developer dashboard simply log in, select your game, then click 'Moderators'!

What if I don't appoint any moderators?
All users have the ability to flag other users via the 'Report Abuse' button on any player's profile. If a player is flagged enough times then they will be banned.

So why have any moderators?
Moderators can actively monitor your chat rooms from any game and out of game using the OpenFeint Moderator Dashboard. note: you must be logged in to access the link. In addition, moderator bans take effect instantly whereas multiple users must flag the same user in order for a ban to be enacted.

What rooms can a moderator moderate in?
Coming soon, sorry :)

Cool, now how long do bans last for?
Coming soon, sorry :)

Are there any basic guidelines for moderators to follow?
Moderators are expected to use their best judgement. Abrasive language, harassment, and inappropriate conduct are not permitted withing OpenFeint chat rooms. Abuse of the moderation system will not be tolerated.