[OpenFeint Developer Support Center] Recently Changed Articles

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.

OpenFeint 2.5 - RESTful API Settings

Wed, 01 Sep 2010 00:13:44 GMT

OpenFeint RESTful API Settings

OpenFeint's new RESTful API gives you open access to your game data such as your leaderboards, achievements, and challenges. Our API data is available in XML or JSON formats to allow for easy integration.

Authentication

Authentication is required when accessing the OF REST API. There 3 alternative ways of providing authentication:

OF dev session key (a cookie kept with your browser when accessing the OF dev dashboard)
Remote host domain when accessing our server from your server (app status on the OF dev dashboard must show as "Approved")
Basic HTTP Authentication with product key and secret

To test these methods, consider the following example where "AppId" and "LeaderboardId" are replaced with your own Client Application ID and chosen leaderboard ID from your OF dev dashboard account:


https://api.openfeint.com/api/games/AppId/leaderboards/LeaderboardId/highscores.xml

The first authentication method can be tested by entering the URL described above in address bar of a web browser while another tab of the same browser is logged in with the OF dev dashboard.

The second authentication method can be tested by entering the URL described above in address bar of a web browser while another tab of the same browser is not logged in with the OF dev dashboard. This will only succeed if the OF dev dashboard shows the app status as "Approved" and the remote host domain has been configured.

The third method encodes Basic HTTP authentication right into the URL via CGI parameters. Append the following URL encoded CGI parameters to the URL described above replacing "ProductKey" and "ProductSecret" with your own key and secret values:


?client_id=ProductKey&client_secret=ProductSecret

Alternatively, you could test Basic HTTP authentication with user and password CGI parameters using your account email address for the user parameter, and your account password for the password parameter.

Making API Requests

By accessing our API directly, you have full access to our API data. Our API is RESTful and is currently available in JSON and XML formats. To retrieve the API data in a particular format, simply add the appropriate format type to the end of the request URL. All request routes are relative to the api.openfeint.com domain and must use the HTTPS protocol.

All requests will require your Client Application ID.

In the following request formats, simply swap out the :client_application_id format placeholder with your Client Application ID. For example, if you wanted to get your game profile in an XML format and your Client Application ID is 123456789, this is what your request would look like:

https://api.openfeint.com/api/games/123456789.xml

How to get your Game profile

Your game profile contains a lot of basic information concerning your game.

Request format:

/api/games/:client_application_id(.:format)

Example:

http://api.openfeint.com/api/games/943342882.xml

What is returned:

id: the Game ID or the Client Application ID of the game.
name: the name of the game.
bundle_id: the current bundle ID of the game.
developer_name: the name of the developer who owns this game.
price: the price currently listed in OpenFeint. This might differ from the App Store price.
description_brief: a small one sentence description of the game. Edited on iPurchase page.
description_extended: the long description of the game. Edited on the iPurchase page.
youtube_url: the url to a youtube video associated with the game.
itunes_id: the itunes id of the game
release_date: the actual release data of the game into the iTunes store.
current_version: the current version of the game.
category: the selected game category
icon_url: url to the game icon used in the OpenFeint catalog and elsewhere
achievements_url: url to the achievements data
leaderboards_url: url to the leaderboards data
challenges_url: url to the challenges data

How to get a list of Leaderboards

Grab your current list of leaderboards, and their associated data. To get the highscores on the leaderboards requires a separate request (see How to get a list of Highscores).

Request format:

/api/games/:client_application_id/leaderboards(.:format)

Example:

http://api.openfeint.com/api/games/943342882/leaderboards.xml

What is returned:

name: the name of the leaderboard.
id: the unique ID of the leaderboard. You will need this to make a highscores request.
size: the approximate size of the leaderboard.
highscores_url: the url to the highscores of the leaderboard.

How to get a list of High Scores

Use this request to get the actual highscores associated with a leaderboard. You will need aleaderboard_id in order to make this request. You can get the leaderboard_id by getting the list of leaderboards (see How to get a list of Leaderboards). The response of a highscores request is paginated, meaning that only a limited number of results are shown at a time. By default, 30 entries are shown at a time. In order to see more results, you must pass in a page parameter into the request. If you want to see more results per page, you can pass in a per_page parameter to set the number of results returned per page.

Request format:

/api/games/:client_application_id/leaderboards/:leaderboard_id/highscores(.:format)

Example:

http://api.openfeint.com/api/games/943342882/leaderboards/746115022/highscores.xml

What is returned:

score: the actual score recorded.
created_at: when the highscore was first created.
updated_at: when the highscore was updated.
display_text: any custom display text associated with the highscore.
user: the following is the user data associated with the highscore

name: name of the user who got the score.
profile_picture_url: the url of the profile picture associated with the user.
open_feint_gamer_score: the openfeint score associated with the user

How to get a list of Achievements

Use this request to get a list of Achievements that a player can earn in your game.

Request format:

/api/games/:client_application_id/achievements(.:format)

Example:

http://api.openfeint.com/api/games/943342882/achievements.xml

What is returned:

title: the title of the achievement
description: a description of the achievement.
gamerscore: the number of OpenFeint points players will receive when they earn this achievement.
is_secret: a true or false value determining if the achievement is hidden from users.

How to get a list of Challenge Definitions

Use this request to get the list of Challenge Definitions and how many users issued that Challenge. We currently do not offer a list of the actual challenges issued and by whom it was issued.

Request format:

/api/games/:client_application_id/challenges(.:format)

Example:

http://api.openfeint.com/api/games/943342882/challenges.xml

What is returned:

name: the name of the challenge definition.
image_url: the url of the image associated with the challenge definition.
size: the number of challenges that have been issued by players using this challenge definition.

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.

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.

Work-Around for trouble with OF+Unity+iOS4

Thu, 08 Jul 2010 01:26:29 GMT

If you are having issues with OpenFeint, Unity, and iOS4 we have a workaround for the most common issue. Please refer to this thread in the developer support forums for more information:

Unable to compile with iOS4

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

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.

Creating a "Favorite This Game" link

Tue, 06 Jul 2010 23:23:47 GMT

OpenFeint 2.5 introduces new high level API’s to make it easier for developers to take advantage of OpenFeint’s broad array of features. All of the old API’s are still there too. The new API’s just wrap them to simplify the typical use cases.

Let’s take a look at an example from the new OFCurrentUser API. Notice that “OFCurrentUser.h” lives in a new “include” directory inside the OpenFeint 2.5 SDK. The header files of this directory make up the new API and document its features. OFCurrentUser contains the class method “favoriteCurrentGame” that you can easily rig up to a button in your UI to make it more convenient for your users to recommend your game to others.

   
+ (void)favoriteCurrentGame:(NSString*)reviewText;

If you provide users with a game summary message when they finish a level, you might want to include a button that lets them conveniently mark the game as one of their favorites and include their own review text. Users can can always get to this feature from the OpenFeint dashboard but if the option appears in your own UI at just the right time they are more likely to make use of it. You could even conditionally include this button only when the end of game stats are reporting on a particularly successful round where the user is more likely to be interested in offering a positive review. The button could also be hidden after the user has already marked the game as a favorite.

All of the new API’s follow a pattern that treat the module, such as OFCurrentUser, as a class wrapping a singleton that keeps track of context and reduces the number of parameters for you to keep track of in each method. Methods that start an asynchronous request handle replies through protocol defined methods of a delegate class that you provide. This won’t seem as complex as it sounds once we’ve finished working through our “favoriteCurrentGame” example below.

Let’s say that your end of game summary screen is handled by your own view controller class called GameSummaryController declared something like this:

   
@interface GameSummaryController : UIViewController
<OFCurrentUserDelegate>

You inform the OFCurrentUser singleton that your GameSummaryController class is the current delegate to handle these callbacks with a “setDelegate” method. A view controller like GameSummaryController can enable and disable this delegation like so:

   
- (void)viewWillDisappear:(BOOL)animated

    {

       
[OFCurrentUser setDelegate:nil];

        [super
viewWillDisappear:animated];

    }



    - (void)viewDidAppear:(BOOL)animated

    {

        [OFCurrentUser
setDelegate:self];

        [super
viewDidAppear:animated];

    }

GameSummaryController will include the following methods of the OFCurrentUserDelegate protocol:

   
- (void)didFavoriteCurrentGame;

    - (void)didFailFavoriteCurrentGame;

These methods let you know whether the server was able to confirm your submission of the following asynchronous request when the user presses your button to mark the game as a favorite:

   
[ OFCurrentUser favoriteCurrentGame: reviewText];

And there you have it. The one line above submits a request to mark a game as favorite. Most of the context is provided by the OFCurrentUser singleton so you don’t have to think about it. Callbacks for completion of asynchronous requests for all features of this API module are handled through a protocol you delegate to one class of your own. This simple pattern is applied throughout the OpenFeint API to make it easier for developers to take advantage of OpenFeint features.

OpenFeint 2.5 - Cloud Storage

Tue, 06 Jul 2010 23:16:24 GMT

Cloud Storage

The OFCloudStorage module allows you to store arbitrary game data on OpenFeint servers. It is primarily intended for stored saved games. The module is represented by the “include / OFCloudStorage.h” header file and provides the following features:

Upload data with a key value
Download data with a key value
Get all key values for a particular user

Note that the "key value" could be something like "SAVED_GAME" in code. Key values are fetched with in the context of applicationId/userId/keyvalue. If the same key value "SAVED_GAME" is used for different users in different games this context assures that the correct context specific value is returned.

Please refer to the corresponding header files for proper usage.

OpenFeint 2.5 - Challenges

Tue, 06 Jul 2010 23:15:28 GMT

Challenges

The user and app info features cover three modules represented by the following header files:

Include / OFChallenge.h
Include / OFChallengeDefinition.h
Include / OFChallengeToUser.h

The OFChallenge module provides the following features:

Create a challenge from a challenge definition
Use the OpenFeint UI to send a challenge and to fill out the challenge after it is created and send it from a customized UI.
Download challenge data for a particular challenge
See the challenge definition that created this challenge
See the challenger
See the challengeDescription
See the user message on the challenge
Read/write "hidden text" (purely a field for the developer to put extra text - this is unused by all systems in openfeint).

The OFChallengeDefinition module provides the following features referring to challenge definitions created in the OpenFeint developer dashboard:

Download all challenge definitions for this app
Get a challenge definition by id
Get icon for a challenge
Get the title of the challenge
See whether this challenge is a multi-attempt challenge.

The OFChallengeToUser module provides the following features:

Read/write to a file
Send completion result either through the Openfeint ui or through a custom ui
Reject a challenge
See the Challenge object that another user created and sent to you
See the result of this challenge
See the result description
See whether this has been viewed by the receiving user
See the number of attempts taken at this challenge by the current user

Please refer to the corresponding header files for proper usage.

OpenFeint 2.5 - Leaderboards

Tue, 06 Jul 2010 23:14:52 GMT

Leaderboards

The leaderboard features cover modules represented by the following header files:

Include / OFHighScore.h
Include / OFLeaderboard.h
Include / OFScoreEnumerator.h
Include / OFAbridgedHighScore.h
Include / OFDistributedScoreEnumerator.h

Note that most games not implementing sophisticated customized leaderboard displays will find all of the leaderboard functionality that they need in just the OFHighScore and OFLeaderboard modules.

The OFHighScore module provides the following features:

Create a high score and submit it to a leaderboard.
Download the high scores "blob" information (data uploaded by the developer when submitting the high score)
Get the score
Get the display text
Get the rank attached to this score
Get which user this score is for

The OFLeaderboard module provides the following features:

Get the leaderboards for this app
Get a leaderboard by the leaderboard Id
Get the High score for the current user on any leaderboard
Get the scores for all local users on the device on any leaderboard
Get Friends scores, or everyones scores for a given leaderboard
Get the name of the leaderboard
Get the leaderboard id
Get the current users score on a leaderboard
Get "descending order" (YES then the highest score value is ranked #1, if NO then the lowest score value is ranked #1.)

The OFScoreEnumerator module provides the following features:
Create a score enumerator, which allows an app to download a set of scores at a time (i.e. give me 25 scores now.... now give me the next 25..... now give me the next 25).

Get the next set of scores
Get the previous set of scores
Get the page of scores that contains the current user
Jump to a page index of scores
Get the page size
Get the current page
Get the total number of pages
Get the scores on the current page

OFAbridgedHighScore is a lightweight version of OFHighScore that provides the following features for use with OFDistributedScoreEnumerator:

Get the score
Get the display text
Get which user this score is for

The OFDistributedScoreEnumerator module provides the following features:
Create a distributed score enumerator, which allows an app to download scores at a set interval of score values (i.e. get me 100 scores with an ideal interval of 1000pts gives scores 100 scores between 1000 and 100.000, page 2 gives 100 scores between 100.000 and 200.000)

Get the next set of abridged scores
Get the previous set of abridged scores
Jump to a page index
Get the page size
Get the current page
Get the abridged scores on the current page.

Please refer to the corresponding header files for proper usage.

OpenFeint 2.5 - Achievements

Tue, 06 Jul 2010 23:14:12 GMT

Achievements

The OFAchievement module is represented by the “include / OFAchievement.h” header file and provides the following features:

Get the achievements for this game
Get an achievement by its id
Unlock an achievement
Unlock an achievement, but defer the server call (used when multiple achievements are unlocked at once)
Submit the defered achievements.
Get the icon for an achievement
Get the name of the achievement
Get the description of the achievement
Get the gamer score attached to this achievement
Get whether or not this achievement is "secret"
Get whether or not this achievement is unlocked by the current user
Get the date this achievement was unlocked by the current user.
Optionally you can set a custom url to be posted with this achievement to social networks if the user decides to post to social networks.

Please refer to the corresponding header files for proper usage.

OpenFeint 2.5 - Communicating with Users

Tue, 06 Jul 2010 23:13:45 GMT

Communicating With Users

User communication features cover modules represented by the following header files:

include / OFSocialNotificationApi.h
include / OFAnnouncement.h
include / OFInviteDefinition.h
include / OFInvite.h

The OFSocialNotificationApi module provides the following features:

Send a social notification with text and an image
Optionally you can also set a link on the social notification

The OFAnnouncement module provides the following features:
Get the announcements for the running app
Get the posts for a certain announcement
Get the body of an announcement

Invite definitions are created on the OpenFeint developer dashboard. The OFInviteDefinition module provides the following features:

Get the primary invite definition (there is always a primary invite definition defined on the dev dashboard unless there are no invite definitions at all)
Get the invite definition by id (incase there are multiple invite definitions)
Get invite icons
Get the name of the application associated with an invite
Get the application id for an invite
Get the invite identifier (put in by the developer in the dev dashboard)
Get the developer-message (uneditable string sent with the invite)
Get the suggested-message (the default message the developer will put in when inviting someone. The user can edit this if the developer uses our invite ui)

An OFInvite object is effectively an instance of created from an The OFInvite module provides the following features:

Invites (The object that is created when an invite is actually made. This is an "instance" of a definition):
Able to create an invite from an invite definition
You can decide to use OpenFeints UI to send the invite after it is created, or you can fill out the information for the invite yourself through a custom api and send it to a list of users.
Set the user message on the invite

Please refer to the corresponding header files for proper usage.

OpenFeint 2.5 - User and Application Info

Tue, 06 Jul 2010 23:13:13 GMT

User & App Info

The user and app info features cover three modules represented by the following header files:

include / OFUser.h
include / OFCurrentUser.h
include / OFPlayedGame.h

The OFUser module provides the following features:

You can get a User by their ID
You can get the friends of any user
You can get the friends that own running application of any user
You can get any users profile picture
Get the users name
Get the users last played game id
Get the users last played game name
Get the users gamerscore
Get whether the user follows the current user
Get whether the user is followed by the current user
Get whether the user is online
Get the users user id

The OFCurrentUser module provides the following features:

You can do all the stuff you can do to a user (listed above) but additionally you can:
Get the current user
Favorite the running application for the current user
Send a friend request from the current user to another user
Unfriend a user from the current users friends
Query if the current user has any friends
Query the current users unview challenge count
Query if the current user allows social notifications
Query if the current user "has any open feint badges". (Unseen stuff in OpenFeint which is pending friends + unviewed challenges + new inbox items).

The OFPlayedGame module provides the following features:

Get a list of featured games by the current application
Get the name of all featured games
Get the client application Id for all featured games
Get the iTunes url to by a featured application
Get the icon for a featured application

Please refer to the corresponding header files for proper usage.

OpenFeint 2.5 - Turn-Based Multiplayer Implementation Guide

Tue, 06 Jul 2010 23:11:53 GMT

OpenFeint Turn-Based Multiplayer Game Implementation Guide

The OpenFeint Turn-Based Multiplayer System is designed to make multiplayer game making easier.

Use OpenFeint's server expertise, instead of having to administrate your own
Simple event-driven interface for move receipt
Multislot lobby allows the player to be in several games at once
Matchmaking
Push notifications keep the player involved even when offline
Handles issue of player dropouts

Limitations

A game can consist of up to 65535 moves.
A move can contain up to 16K of data that can contain any information you wish
At the moment, only 2 player games are supported, future plans will increase that number
In order to make use of the offline capabilities, the game engine must be written to be completely deterministic. The configuration, creation options, a random seed and a list of moves must be sufficient to allow the current game state to be built. A random seed will be generated by the server when a game is created, either use that with the built-in random number generator (a simple Linear Congruential) or use it to seed your own. When a player returns to a given game, the moves will be returned in server order.

Definitions
Anomaly -a special move type that is requested by a player other than the current player. Used to handle player drop-outs mostly.   Anomalies require a reason that the server should accept them.
Game - an interaction between different players with a state defined by an initial state consisting of a configuration string, game options and a generated seed and a series of moves.
Lobby - a list of slots that contains current game information. This allows the player to be offline in several games at once, if that is desired.
Move - a change of state requested by a client.   Moves can contain arbitrary data, signal end of turn, end of game, or a player's resignation.   Moves can be generated by a player if the current game state allows them to enter moves or you can request the server enter a move using anomalies.
Slot - represents a single potential or actual game to the lobby.

Type of games
The system can support several different types of multiplayer game
1) Sequential turn - Example Chess.   In this version, only one player is making moves at any given time and only one player is allowed to make moves at any time.   This is the easiest to program as the order of moves is strictly determined.

2) Simultaneous Turn - Gated.   Example Roshambo (rock-paper-scissors).   In this game mode, the players are allowed to make moves at the same time, when all players have made moves the game state is updated..   This requires some work on the part of the game logic so that move order does not affect the game state and no one is allowed to make more moves than is valid.   For Battleship, each player is allowed to make all the moves in their salvo. The game logic does not allow the player to shoot more times than allowed by salvo, and since the player shots are all evaulated at once, there isn't a problem where turn order is a difficultly.

3) Simultaneous Turn - Interruptable.    Example Magic: The Gathering.    In this version, the players can actually affect each other's play. This is by far the hardest type to program, because interactions between the player moves can be difficult to reconcile.   For instance, suppose a game allows you to attack a piece in range. You make that move, on your client it appears you are attacking the piece.   Unfortunately, the other player is online and has moved out of range.   Thus on their machine, it does not register as a strike. To help avoid this, you can specify that a move is given with delay.   This move should not be applied to the game state until the server echoes it back as a regular move. That way, it will be in the order sent to all the clients.   For the shot, when the player triggers the shot, nothing happens until the server returns a message at which point the logic can determine if there's a hit. The other client will have to display the shot attempt at the time of receipt, so there will be a slight visual difference.

It may be tempting to try to create a pseudo-realtime game using this system, but that is not recommended.   It's recommended for things like in head-to-head games where achieving a certain result causes an effect on the opponent (like clearing blocks in Tetris hurting the opponent)

4) Free-for-all.   Example Super Puzzle Fighter. The game state is not completely controlled by the server. In this game type, the offline capabilities cannot be used.   The game moves instead are used to send snapshots of the current state back and forth.   There is no direct interaction between the players, although sending a move can send a message that affects that player's state.   In this case, the victory goes to the first player who claims it. To do something like Super Puzzle Fighter, when an attack is made, that move will trigger the cascade when it is received.   The system can also send updates back and forth.

Samples
The samples are shipped as folders with the specific classes for that sample. These must be added to a standard OpenFeint project of at least version 2.4.7.   The OpenFeintMultiplayer folder should also exist at the top level.   The application Key and Secret can be found by registering at the regular OpenFeint developer site.   http://www.openfeint.com/developers.

Battleship

The Battleship GameManager can be used as an example of writing a multiplayer engine.   It can be considered a Controller, with the internal GameGrid containing the Model.   The work of changing the user input into moves is handled in the BattleShipGameViewController. These moves are send to the GameManager along with moves received from the network.   The manager handles the question of what is a valid move in the current state and tests for game completion.

MPSampleApp

This sample shows the use of several of the more advanced systems.   From a multiple slot lobby, you can enter up to 6 games at once. When a slot is selected, you can enter that game, make some moves (press U,D,L,R).   In addition, this sample shows how to challenge a friend, allow rematches, and handle push notifications. Moves to the right are sent using the move with delay. Note that this is an older sample and reflects an earlier version of the API, but it remains here to show those particular features.

OpenFeint 2.5 - Unlock an Achievement

Tue, 06 Jul 2010 23:11:07 GMT

OpenFeint must be properly integrated and initialized.
A delegate class must handle OFAchievement callbacks.
Obtain a reference pointer to the achievement to be unlocked.
Send the “unlock” message to the achievement.
Check callbacks for a server response.

Unlocking an achievement is one of the simplest OpenFeint features to add to a game. It was not difficult to do with the old API but with the new API it follows a pattern that, once learned, applies to many different features. In general, the new API stores more contextual information in singletons managed through class methods so that features require fewer parameters to use. With fewer parameters to think about and a common calling pattern there is less to learn and remember when making use of more OpenFeint features in your game.

In step 1, we integrate and initialize OpenFeint. This step has not changed from the previous API and is still covered in the “ReadMe.txt” file that comes with the SDK and the “Getting Started” of our online developer support center and knowledge-base.

In step 2, we supply a delegate class to handle OFAchievement callbacks. We do this by adding the OFAchievementDelegate protocol declared in OFAchievement.h to a class of our own and telling the OFAchievement class when our delegate is ready to handle any of the callbacks required in the protocol. The following line informs the OFAchiement class singleton that our delegate is ready to be used:

   
[OFAchievement setDelegate: instanceOfMyDelegateClass]

This same call with a nil parameter will tell the OFAchievement class that the delegate will no longer be answering callbacks defined for the OFAchievementDelegate protocol.

In step 3 we obtain a reference pointer to the achievement to be unlocked. The only parameter required is an ID from the developer dashboard to distinguish which achievement we are interested in:

   
OFAchievement *myAchievement = [OFAchievement
achievement:(NSString*)achievementId];

In step 4, we send the “unlock” message to the achievement. Note that the return value supplies a request handle that is only needed if you might want to cancel a server request before it has completed:

  
 OFRequestHandle *myRequestHandle = [myAchievement unlock];

In step 5, the callback methods of the currently assigned delegate will be called to provide an asynchronous response to a server request. Use these to handle the success or failure of the request as suits your application.

And there you have it; everything needed to unlock an achievement using the new OpenFeint API. Note that the OFAchievement.h header file documents the all the features of the API module relating to achievements. It lives in a new “include” directory that contains all the other header files describing the features of all the modules of the new API.

Free to Paid App Promotion With OpenFeint

Tue, 01 Jun 2010 22:23:34 GMT

As discussed in a previous article, there are a variety of techniques for promoting up-sell from free to paid apps. This article focuses on one of the most common techniques in which the developer separately lists both free and paid versions of their app in the app store.

As far as OpenFeint's servers are concerned your app is distinguished by its OpenFeint product key and app version number. Ordinarily, each separate app will have it's own product identity in the OpenFeint developer dashboard which is associated with one product key. In the case of a free app created to showcase a subset of features in a corresponding paid version, it is often desirable to use the same OpenFeint product key in both the free and paid versions of the app. One benefit of sharing a product key in this way is that users of both versions can see the same set of leaderboards even though the code in the free version may restrict the user to only be able to play and submit high scores for one trial level leaderboard.

One limitation of sharing one product key in both the free and paid versions of your app is that there is only one product identity associated with that product key as defined in the OpenFeint developer dashboard. To get around this limitation, we recommend:

Developers create a product identity for each version of the app in the OpenFeint developer dashboard even though both apps only use the product key associated with the paid version.
The product key and all of the developer dashboard pages associated with the free app are ignored except for the app name, the version code, and the iPurchase page.
In the dashboard pages for both the free and paid apps, the bundle identifier should be set to "1" instead of the actual bundle ID. This will cause OpenFeint to ignore the bundle ID.

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

OpenFeint Developer License Agreement

Fri, 28 May 2010 23:27:55 GMT

Aurora Feint, Inc.
Developer License Agreement

IMPORTANT – PLEASE READ THE TERMS OF THIS DEVELOPER LICENSE AGREEMENT (THIS “AGREEMENT”) CAREFULLY. BY CLICKING ON THE “I AGREE” BUTTON, (1) YOU ACKNOWLEDGE THAT YOU HAVE READ, UNDERSTAND, AND AGREE TO BE BOUND BY THIS AGREEMENT, (2) YOU REPRESENT THAT YOU HAVE THE AUTHORITY TO ENTER INTO THIS AGREEMENT, PERSONALLY OR ON BEHALF OF THE COMPANY YOU HAVE NAMED AS THE DEVELOPER (THE “DEVELOPER”), AND TO BIND THE DEVELOPER TO THE TERMS OF THIS AGREEMENT, AND (3) YOU REPRESENT THAT YOU ARE NOT A COMPETITOR OF AURORA FEINT. IF YOU DO NOT AGREE TO ALL THE TERMS AND CONDITIONS OF THIS AGREEMENT, OR IF YOU DO NOT HAVE SUCH AUTHORITY, OR IF YOU ARE A COMPETITOR OF AURORA FEINT, YOU SHOULD CLICK ON THE “CANCEL” BUTTON TO DISCONTINUE THE DOWNLOAD OF THE SOFTWARE.

This Agreement is a legal agreement between Developer and Aurora Feint, Inc. (“Aurora Feint”) for the accompanying Aurora Feint software (the “Software”) and associated “online” or electronic documentation (the “Documentation”).
1.
Licenses
1.1
Development License. Subject to the terms and conditions of this Agreement, Aurora Feint grants to Developer a nonexclusive, worldwide, nontransferable (except in accordance with Section 15), royalty-free, fully paid, revocable (in accordance with Section 12), nonsublicenseable license to permit those employees or consultants of Developer authorized by Developer (“Authorized Users”) to internally (a) use, perform, display, reproduce, modify, and create derivative works of, the sample source code included in the Software for the sole purpose of creating executable object code for incorporation in Developer Products to permit such Developer Products to run on the OpenFeint Platform (as defined herein) in compliance with the Platform Requirements (as defined in Section 6); (b) compile such sample source code or derivatives thereof into executable object code for incorporation in Developer Products to permit such Developer Products to run on the OpenFeint Platform in compliance with the Platform Requirements; and (c) reproduce and use, a reasonable number of copies of, the Documentation in support of the exercise of the licenses granted in clauses (a) and (b) herein. “Developer Products” means software applications developed by or on behalf of Developer and branded with Developer brands, logos, trade marks, and/or trade name. “OpenFeint Platform” means Aurora Feint’s OpenFeint software platform provided on a hosted basis by or on behalf of Aurora Feint, as such platform may be modified or enhanced from time to time by Aurora Feint.
1.2
Distribution License. Subject to the terms and conditions of this Agreement, Aurora Feint grants to Developer a nonexclusive, worldwide, nontransferable (except in accordance with Section 15), royalty-free, fully paid, revocable (in accordance with Section 12), license to reproduce and distribute (solely in accordance with Section 4) the sample source code included in the Software or derivatives thereof solely as compiled into executable object code incorporated in Developer Products that (a) comply with the Platform Requirements, (b) are approved by Aurora Feint to run on the OpenFeint Platform as described in Section 7, and (c) comply with the branding requirements specified in Section 3.
2. Restrictions. Developer acknowledges that the Software (including, all sample source code) and Documentation and all elements thereof, and their structure and organization, constitute Aurora Feint’s confidential information. Accordingly, Developer agrees to, and Developer shall cause each Authorized User to agree in an enforceable writing to, treat all such Software and Documentation as confidential material in a manner no less protective than Developer uses to protect its own similar assets, but in no event less than reasonable care. Except as expressly permitted in this Agreement, if at all, Developer shall not, and Developer shall cause each Authorized User not to, (a) license, sell, rent, lease, transfer, assign, distribute, display, host, outsource, disclose or otherwise commercially exploit or make the Software or Documentation available to any third party; (b) modify, make derivative works of, disassemble, reverse compile or reverse engineer any part of the Software; (c) access the Software in order to build a similar or competitive product or service; or (d) reproduce, distribute, republish, download, display, post, or transmit, in any form or by any means, including electronic, mechanical, photocopying, recording, or other means any part of the Documentation. Any future release, update, or other addition to the functionality of the Software, if any, provided by Aurora Feint shall be subject to the terms of this Agreement. Neither Aurora Feint nor any of its suppliers is obligated to provide any services, updates or upgrades to the Software. Developer shall, and Developer shall cause each Authorized User to, preserve all copyright and other proprietary rights notices in the Software and Documentation and all copies of the Software and Documentation.
3. Branding. Developer will brand Developer Products with its own brands, logos, trade marks, and/or trade name; provided, however, that Developer shall include the Aurora Feint Marks (as defined herein) on or within the Developer Product in accordance with the OpenFeint Branding Guidelines (as defined herein) and the other provisions of this Section. Subject to the terms and conditions of this Agreement, Aurora Feint grants to Developer a non-exclusive, worldwide, nontransferable (except as permitted under Section 15), revocable (in accordance with Section 12), royalty-free and fully-paid, non-sublicenseable license to use and reproduce the Aurora Feint Marks in accordance with the OpenFeint Branding Guidelines and solely in connection with marketing the OpenFeint Platform and distributing the Software as incorporated in the Developer Product. Developer agrees to state in appropriate places on all materials using the Aurora Feint Marks that the Aurora Feint Marks are trademarks of Aurora Feint and to include the symbol ™ or ® as appropriate. Aurora Feint grants no rights in the Aurora Feint Marks other than those expressly granted in this Section 3. Developer acknowledges Aurora Feint’s exclusive ownership of the Aurora Feint Marks. Developer agrees not to take any action inconsistent with such ownership and to cooperate, at Aurora Feint’s request and expense, in any action (including the conduct of legal proceedings) which Aurora Feint deems necessary or desirable to establish or preserve Aurora Feint’s exclusive rights in and to the Aurora Feint Marks. Developer will not adopt, use, or attempt to register any trademarks or trade names that are confusingly similar to the Aurora Feint Marks or in such a way as to create combination marks with the Aurora Feint Marks. Developer will provide Aurora Feint with samples of all products and materials that contain the Aurora Feint Marks prior to their public use, distribution, or display for Aurora Feint’s quality assurance purposes and will obtain Aurora Feint’s written approval before such use, distribution, or display. At Aurora Feint’s request, Developer will modify or discontinue any use of the Aurora Feint Marks. “Aurora Feint Marks” means the Aurora Feint brands, logos, trade marks, and/or trade name listed in the OpenFeint Branding Guidelines, as such brands, logos, trade marks, and/or trade name may be updated from time to time by Aurora Feint by updating such list in the OpenFeint Branding Guidelines. The “OpenFeint Branding Guidelines” means Aurora Feint’s then-current trademark guidelines for products using the OpenFeint Platform as such guidelines may be amended by Aurora Feint from time to time and posted at www.openfeint.com/developers/support/index.php/kb/article/000032.
4. Distribution. Before distributing any Developer Product that incorporates any Software to any subdistributor or end user, Developer must require the subdistributor or end user, as applicable, to agree in an enforceable writing that: (a) title to and ownership of the Software remains with Aurora Feint, (b) it shall not alter or modify the Software, (d) it/he/she shall not reverse engineer, decompile, disassemble, or attempt to derive the source code of the Software, (c) it/he/she shall reproduce all copyright and other proprietary rights notices on any copies of the Software made by it/him/her, (d) it/he/she shall comply with all applicable laws, including export and re-export laws, with respect to the Software, (e) all express and implied warranties regarding the Software are disclaimed by Aurora Feint, and (f) all direct, consequential, special, and indirect damages arising from or related to the Software are disclaimed by Aurora Feint. Developer will enforce each such agreement with at least the same degree of diligence that Developer uses to enforce similar agreements for its own products, but in no event less than reasonable efforts. Developer will immediately notify Aurora Feint if Developer becomes aware of any material breach of any such agreement relating to the Software.
5. Ownership. All right, title, and interest, including all intellectual property rights, in and to the Software, Documentation, including any and all copies of the Software and Documentation, and the OpenFeint Platform (collectively, “Aurora Feint Property”) shall be owned and retained by Aurora Feint and its licensors. Developer acknowledges that it acquires no ownership interest in any Aurora Feint Property. All right, title, and interest, including all intellectual property rights, in and to the Developer Products (excluding any Aurora Feint Property incorporated therein) (the “Developer Property”) shall be owned and retained by Developer and its licensors. Aurora Feint acknowledges that it acquires no ownership interest in any Developer Property. Any rights not expressly granted in this Agreement are reserved by the parties. There are no implied licenses in this Agreement.
6. Platform Requirements. Any Developer Product that incorporates any Software must comply with Apple, Inc.’s content standards located at http://developer.apple.com. In addition, Developer represents, warrants, and covenants that:
(a)
Developer Product shall not access or use the OpenFeint Platform except in the manner prescribed by Aurora Feint;
(b)
Developer Product shall not use any robot, spider, site search, or other retrieval application or device to scrape, retrieve, or index services provided by Aurora Feint or its licensors, or to collect information about users for any unauthorized purpose;
(c)
Developer Product shall not disable, override, or otherwise interfere with any Aurora Feint implemented system alerts, warnings, display panels, consent panels and the like intended to notify the user that the user's location data is being collected, transmitted, maintained, processed, or used, or intended to obtain consent for such use;
(d)
Developer Product shall not contain any viruses, Trojan horses, worms, time bombs, cancelbots, easter eggs or other computer programming routines that may damage, detrimentally interfere with, surreptitiously intercept or expropriate any system, network, services, data, or personal information;
(e)
Developer shall ensure that any open source software used in the development of the Developer Product does not subject any portion of the Software or OpenFeint Platform proprietary to Aurora Feint to become subject to any open source obligation or condition.
(f)
Developer Product shall not infringe any third party's copyright, patent, trademark, trade secret or other proprietary rights or rights of publicity or privacy;
(g)
Developer Product shall not violate any law, statute, ordinance or regulation (including those governing export control, consumer protection, unfair competition, antidiscrimination or false advertising);
(h)
Developer Product shall not contain content that is defamatory, trade libelous, unlawfully threatening or unlawfully harassing;
(i)
Developer Product shall not contain obscene content or child pornography;
(j)
Developer Product shall not collect or attempt to collect personally identifiable information of any person, except with their prior written consent and of which consent Developer shall maintain a written record for a period of three (3) years after any termination of this Agreement;
(k)
Developer Product shall not be harmful or potentially harmful to the OpenFeint Platform or the systems and server structure, security mechanisms, services used by Aurora Feint to provide and support the OpenFeint Platform as determined in Aurora Feint’s sole discretion; and
(l)
Developer Product shall not create liability for Aurora Feint. The requirements specified in this Section, as such requirements may be modified by Aurora Feint from time to time by posting the revised requirements on the OpenFeint website located at www.openfeint.com/developers (“OpenFeint Website”), are referred to as the “Platform Requirements.” Developer agrees to indemnify and hold Aurora Feint and its affiliates, officers, employees, agents, suppliers, and OpenFeint Platform users, harmless from and against any and all claims, suits, actions, losses, costs (including attorneys’ fees), liabilities, damages, and expenses arising from or relating to any claim or demand made by any third party arising out of or related to Developer’s violation of the Platform Requirements.
7.
Approval. Before distributing any Developer Product that incorporates any Software, Developer shall submit such Developer Product (including its config file) to Aurora Feint for testing and evaluation purposes. With the assistance and cooperation of Developer, Aurora Feint will use reasonable commercial efforts to test and evaluate the Developer Product for compatibility with the OpenFeint Platform and for compliance with the other requirements of this Agreement. Aurora Feint may accept or reject the Developer Product in its sole discretion. If Aurora Feint rejects the Developer Product, it may provide Developer with details of any problems or issues found in the Developer Product whereupon Developer may correct those problems and issues and resubmit the Developer Product for further evaluation by Aurora Feint in accordance with this Section. If Developer does not receive any written notice of approval or rejection of the Developer Product within thirty (30) days following Developer’s submission thereof, Aurora Feint will be deemed to have rejected the Developer Product. Developer shall not distribute any Developer Product that has not been approved in writing by Aurora Feint. Aurora Feint’s approval of any Developer Product under this Section shall not constitute a waiver of any of Aurora Feint’s rights or Developer’s obligations under this Agreement and Developer shall remain responsible and liable for any breach of the other Sections of this Agreement, including the Platform Requirements, notwithstanding any approval by Aurora Feint of the applicable Developer Product. Developer hereby grants us a worldwide, non-exclusive, transferable, sublicenseable, fully paid and royalty-free license, under Developer’s intellectual property rights in and to the Developer Product, to execute and use the Developer Product for the purposes of testing and evaluating the Developer Product.
8.
Feedback. Any and all suggestions, ideas, recommendations, and feedback provided to Aurora Feint by Developer regarding the functioning, features, and other characteristics of the Software, Documentation, or OpenFeint Platform (collectively, “Feedback”) is hereby licensed by Developer to Aurora Feint on a worldwide, perpetual, irrevocable, non-exclusive, transferable, sublicenseable, fully-paid and royalty-free basis, for Aurora Feint to use and exploit the Feedback in any manner and for any purpose.
9.
DISCLAIMER OF WARRANTIES. THE SOFTWARE, DOCUMENTATION, AND OPENFEINT PLATFORM ARE PROVIDED ON AN “AS-IS” BASIS. AURORA FEINT PROVIDES NO TECHNICAL SUPPORT, WARRANTIES, OR REMEDIES FOR THE SOFTWARE OR OPENFEINT PLATFORM. AURORA FEINT AND ITS SUPPLIERS DISCLAIM ALL EXPRESS, IMPLIED OR STATUTORY WARRANTIES RELATING TO THE SOFTWARE, DOCUMENTATION, AND OPENFEINT PLATFORM INCLUDING MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT. AURORA FEINT DOES NOT WARRANT THAT USE OF THE SOFTWARE OR OPENFEINT PLATFORM WILL BE UNINTERRUPTED OR ERROR-FREE, THAT DEFECTS WILL BE CORRECTED, OR THAT THE SOFTWARE OR OPENFEINT PLATFORM IS FREE OF VIRUSES OR OTHER HARMFUL COMPONENTS. IF APPLICABLE LAW REQUIRES ANY WARRANTIES WITH RESPECT TO THE SOFTWARE, ALL SUCH WARRANTIES ARE LIMITED IN DURATION TO NINETY (90) DAYS FROM THE DATE OF DOWNLOAD.
10.
LIMITATION OF LIABILITY. NEITHER AURORA FEINT NOR ITS SUPPLIERS SHALL BE RESPONSIBLE OR LIABLE WITH RESPECT TO THIS AGREEMENT, OR THE SOFTWARE, DOCUMENTATION, OR OPENFEINT PLATFORM UNDER ANY CONTRACT, NEGLIGENCE, STRICT LIABILITY OR OTHER THEORY (A) FOR LOSS OR INACCURACY OF DATA OR COST OF PROCUREMENT OF SUBSTITUTE GOODS, SERVICES, OR TECHNOLOGY, OR (B) FOR ANY INDIRECT, INCIDENTAL, CONSEQUENTIAL, SPECIAL, OR EXEMPLARY DAMAGES INCLUDING, LOSS OF REVENUES AND LOSS OF PROFITS. AURORA FEINT’S AGGREGATE CUMULATIVE LIABILITY HEREUNDER SHALL NOT EXCEED THE GREATER OF FIFTY U.S. DOLLARS (50.00 USD) OR THE AMOUNT PAID BY DEVELOPER FOR THE SOFTWARE THAT CAUSED SUCH DAMAGE. CERTAIN STATES AND/OR JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES OR LIMITATION OF LIABILITY FOR INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THE EXCLUSIONS SET FORTH ABOVE MAY NOT APPLY TO DEVELOPER.
11.
Basis of Bargain. The warranty disclaimer and limitation of liability set forth above are fundamental elements of the basis of the agreement between Aurora Feint and Developer. Aurora Feint would not be able to provide the Software or OpenFeint Platform on an economic basis without such limitations. The warranty disclaimer and limitation of liability inure to the benefit of Aurora Feint’s suppliers.
12.
Term and Termination. This Agreement and the licenses granted hereunder are effective on the date Developer accepts the terms of this Agreement and shall continue unless this Agreement is terminated by either party pursuant to this Section. Aurora Feint may terminate this Agreement immediately upon written notice to Developer in the event that Developer materially breaches any of the terms hereof. Developer may terminate this Agreement at any time upon written notice to Aurora Feint, with or without cause. Developer may terminate this Agreement by sending either an email to contact@openfeint.com with Developer’s name and the subject “TERMINATION OF DEVELOPER LICENSE” or a letter by United States mail to: Aurora Feint, Inc., License Administration, 330 Primrose Road, Suite 515, Burlingame, CA 94010 or to such other address as Aurora Feint may specify in writing by posting the new address on the Aurora Feint website. Upon any termination, the licenses granted hereunder shall immediately terminate and Developer shall immediately destroy any copies of the Software in its possession and shall cease, and shall cause its subdistributors to cease, distribution of any Developer Products that incorporate any portion of the Software. However, any sublicenses granted to end users by Developer for any Developer Products distributed in accordance with this Agreement shall survive in accordance with their terms. The following terms shall survive any termination of this Agreement: Sections 2 (Restrictions), 5 (Ownership), 6 (Platform Requirements), 8 (Feedback), 9 (Disclaimer), 10 (Limitation of Liability), 11 (Basis of Bargain), 12 (Term and Termination), 14 (Export), and 16 (Miscellaneous).
13.
Modifications. Aurora Feint reserves the right to change the terms and conditions of this Agreement or its policies relating to the Software and/or Documentation. If we make any material change to this Agreement, we will notify Developer by prominently posting notice of the change on the OpenFeint Website or sending Developer an e-mail to the address that Developer provided us. Developer’s continued use or distribution of the Software or Documentation after notice of any such change has been provided in accordance with this Section shall constitute Developer’s consent to such change. Aurora Feint reserves the right to change, modify, and otherwise convert the technology (including the Software) used to provide the OpenFeint Platform; provided that the basic functionality in any given version of the Software itself will not be changed for at least six (6) months following the general release of that version of the Software.
14.
Export. The Software and related technology are subject to U.S. export control laws and may be subject to export or import regulations in other countries. Developer agrees to strictly comply with all such laws and regulations and acknowledges that it has the responsibility to obtain authorization to export, re-export, or import the Software and related technology, as may be required. Developer will indemnify and hold Aurora Feint and its affiliates, officers, employees, agents, and suppliers harmless from any and all claims, suits, actions, losses, costs (including attorneys’ fees), liabilities, damages, expenses, fines, and penalties arising from or relating to any breach by Developer of its obligations under this Section.
15.
Assignment. Neither any right nor any obligation arising under this Agreement is assignable by Developer without Aurora Feint’s prior written consent, and any attempted assignment or transfer by Developer in violation of the foregoing shall be void and without effect. A change of control of Developer is deemed to be an “assignment” for the purposes of this Section. Aurora Feint may assign this Agreement without restriction.
16.
Miscellaneous. This Agreement shall be governed by and construed in accordance with the laws of the State of California and the United States without regard to any conflict of laws principles therein that would require application of the laws of another State or country. Any action under or relating to this Agreement shall be brought solely in the state and federal courts located in California, with sole venue in the courts located in Santa Clara County and each party hereby submits to the personal jurisdiction of such courts, except that Aurora Feint may seek relief in any court of competent jurisdiction to protect or enforce its intellectual property and proprietary rights. The United Nations Convention on Contracts for the International Sale of Goods shall not apply to this Agreement. In the event that any provision of this Agreement is found to be contrary to law, then such provision shall be construed as nearly as possible to reflect the intention of the parties, with the other provisions remaining in full force and effect. Any notice to Developer may be provided by email. This Agreement constitutes the entire agreement between the parties pertaining to the subject matter hereof, and any and all written or oral agreements previously existing between the parties are expressly canceled. Except as otherwise provided in Sections 3 (Branding), 6 (Platform Requirements), and 13 (Modifications), any modifications of this Agreement must be in writing and agreed to by both parties. As used in this Agreement, the word “including” means “including but not limited to.” Notwithstanding anything to the contrary in this Agreement, if Developer has executed a print version/signed agreement with Aurora Feint regarding the Software or Documentation, that print version/ signed agreement will control.

QUESTIONS OR ADDITIONAL INFORMATION. If Developer has any questions regarding this Agreement, or wish to obtain additional information, please send an e-mail to contact@openfeint.com.

Build Error FAQ

Fri, 28 May 2010 23:21:34 GMT

Q-001: I want to see a working OpenFeint sample app and experiment with it's features ASAP.
A-001: 5 Steps:
Log In to the OpenFeint Developer Dashboard at api.openfeint.com.
Create a new app identity (green plus sign in upper left) or select an existing one and locate it's product key (first tab in developer dashboard).
Download the SDK and open the enclosed sample app in XCode.
Locate the call to "initializeWithProductKey" and paste in a product key and secret from the developer dashboard.
Build and run the app to experiment with OpenFeint features and trace through working code.

Q-002: I'd like to dive in and add OpenFeint to my own app ASAP. I am an experienced iPhone developer who does not need a lot of hand holding.
A-002: The integration steps listed in the Readme.txt file of the OpenFeint SDK give the essentials without sugar coating.

Q-003: Why is everything going haywire since I upgraded to the latest beta version of the iPhone SDK?
A-003: OpenFeint only supports release versions of Apple's SDKs and tools.

Q-004: Why is everything going haywire since I upgraded my app from one version of OpenFeint to another?
A-004: XCode's file dependency relationships can get messed up when you switch source files for an existing project. It is often necessary to delete the existing app from the device or simulator in addition to performing a "clean build" to correct these problems. [Resource data sitting in a previously created app bundle dependent on xib files is particularly susceptible to getting their dependencies out of sync when their source files are updated but have a time stamp older than the last created binaries. Updating an SDK can easily trigger this situation.]

Q-005: My build process failed with OpenFeint and reported undefined symbols.
A-005: Here are some typical cases:
Some required framework is missing.
For example, "_uncompress" indicates zlib may be missing.
Something beginning with "OF" is missing
Revisit the Readme.txt step for including the precompiled header file "OpenFeintPrefix.pch".

Q-006: There are hundreds of compiler errors and I don't know where to begin.
A-006: Revisit the Readme.txt step for configuring build settings. One error here may look like hundreds of errors during build. It is also possible that your build dependencies are messed up and should be cleared as described in A-004.

Q-007: I've got a bunch of build errors of the form "ISO C++ forbids declaration of 'identifier' with no type" where 'identifier' is substituted with some other name.
A-007: This is one common symptom of messed up build dependencies and should be cleared as described in A-004.

Q-008: I am trying to build for iPhone OS 2.2.1 to maximize the number of devices my app supports. Unfortunately, the MapKit framework cannot be found.
A-008: We recommend that you set the deployment target in your build settings as far back as iPhone OS 2.2.1 if you want to reach a large installed based with your app. However, the MapKit framework was not introduced until iPhone SDK 3.0. The solution is to set the active build target to the most recent iPhone SDK available, at least version 3.0 even though the deployment target in your build settings allows compatibility with older devices. Note the the active build target can be set via the pull down menu in the upper left corner of the XCode project window.

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];
}

Disabling Chat

Wed, 14 Apr 2010 00:35:41 GMT

Some developers wish to disable access to chat features within their app. There is a settings key that can be used during initialization of OpenFeint to control access to chat features.

"OpenFeintSettingDisableUserGeneratedContent" settings key

To disable chat, add the "OpenFeintSettingDisableUserGeneratedContent" settings key with a boolean true value in the settings dictionary that you pass in to the initialization method. For example:

NSDictionary* settings = [NSDictionary dictionaryWithObjectsAndKeys: [NSNumber numberWithInt:UIInterfaceOrientationLandscapeRight], OpenFeintSettingDashboardOrientation, [NSNumber numberWithBool:YES], OpenFeintSettingDisableUserGeneratedContent, nil];

Game Center Support

Fri, 09 Apr 2010 01:01:28 GMT

You can be 100% assured that we will continue to invest in the OpenFeint platform so that players and developers enjoy a flawless experience with Game Center.

We are currently developing code that will allow you to integrate OpenFeint leaderboards with Game Center and it will be available when Apple's platform launches later this year.

As the platform matures and we have additional information we will post updates here for all developers. If you have additional questions or feedback please use the Contact Us form.

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