1.1 Overview

The Analytics API provides developers with a means of tracking user game information. This includes session durations, how long the average player spends in an average round of play, as well as tracking other events such as item pick-ups, reaching waypoints.

1.2 Prerequisites

MochiAPI is not compatible with versions prior to Flash Player 9, and is no longer compatible with ActionScript 1.0.

Installing the Mochi Analytics Tracking API

1. Download and unzip the latest MochiAPI.
2. Copy the “mochi” folder and paste it into the root classpath of your game. Most often this is the same as the location of your game’s FLA file.

1.3 Connecting to MochiServices

1.1 Prerequisites:

MochiAPI is not compatible with versions prior to Flash Player 9, and is no longer compatible with ActionScript 1.0.

Before you get started, make sure you have done the following:

1. Sign up for a Mochi Developer account on www.mochimedia.com
2. Log in and add a new game to your account.
3. Download the MochiAPI classes ZIP package.
4. Choose your code options and copy the Mochi Ads API in-game code.

1.2 The Mochi API Ad Codes:

If you ever find yourself forgetting how to implement the ad code, you can find a customized code snippet by going to your Mochi developer dashboard, selecting your game, click on "Ads" on the left and then "Mochi Ads Code: Get the ad code and installation instructions" beneath the Default Ad Settings.

Also, there are different examples for ads in the "examples" directory.

Figure a: The MochiAPI ZIP package folder structure.

You need two things for Mochi Ads API to work properly in your game -- The mochi include folder, and the in-game code.

The include folder contains the ActionScript code that your game will reference to display your ad. You will never need to edit this code. You just need to make sure that it is in the proper location so that it is imported or included when you publish or compile your game. You only need to do this once for each game, no matter how many ads you show in the game.

The in-game code is the code you paste into your game to display the ad at a specific point in the game. This may be placed in a specific frame on the main timeline of your movie, or called when a specific event is called in your game code. Depending on how you created your game, where you place this code will differ. Just remember, when you make the call to the Mochi Ads API, that's when the ad will show.

Include Folder Installation:

The MochiAPI ZIP package contains the include code necessary for your game. UnZIP the package to a location on your hard drive. If you browse to that location, you will see a group of folders (fig.a).

Make sure to read the README.TXT file for information regarding the latest release of the MochiAPI file include.

Each folder in the package corresponds to a particular coding environment. It's up to you to choose which one is best for you:

• docs: MochiAPI usage documentation.
• examples: Examples using MochiAPI.
• mochi: MochiAPI include folder.

Simply copy the mochi folder and paste it into the location where you are publishing your game. You do not need to create a special folder for the include (fig.b).

These instructions also apply to the examples. Simply copy the mochi folder into the example project direct that you wish to use, and publish to test.

Adding the In-game Code:

The in-game code is a one-line code snippet that you copy from the Mochi Developer web site. This code is a method call that tells MochiAPI to launch your ad. You will paste this code into your game in the place where you want the ad to appear. Your code looks something like this:

AS2:

import mochi.as2.*;
MochiAd.showPreGameAd({id:"xxxxxxxxxxxxxxxx", res:"360x240"});

AS3:

import mochi.as3.*;
MochiAd.showPreGameAd({id:"xxxxxxxxxxxxxxxx", res:"360x240"});

NOTE: In the 3.0 revision of the API, we changed namespaces for our libraries to unify and organize our packages. Now you must explicitly call the API corresponding to your ActionScript version: mochi.as2.* or mochi.as3.* respectively. For the purposes of this documentation we will show examples specifying the ActionScript 2.0 MochiAPI. Simply remove mochi.as2. from the code samples, and add import mochi.as3.*; to the beginning of your code block to use the ActionScript 3.0 MochiAPI.

There are five types of ads you can place in your game -- a pre-game ad, an inter-level ad, showcase ads, dock ads and a Click-away ad. Pre-game ads include a preloader bar that grows as your game file is loaded from the web to the player's computer. An inter-level ad is an ad that appears at some point during game-play. The most convenient and unobtrusive time to show ads is usually between game levels, hence the name inter-level ad. Click-away ads are 300x250 ads that can be placed anywhere you specify and will only disappear on a user-initiated action. Both the Showcase and the Dock type load a group of small, thumbnail ads into a frame. Each ad in the frame has its own tracking and clickthrough URLs, and a mouse-over caption bubble. Showcase and Dock types are essentially the same except for their visual appearance and behavior in the game window, and one additional API call available to the Dock type.

You can use the Mochi Developer web site to customize your code for the particular type of ad and version of ActionScript you need.

ACTIONSCRIPT 3 NOTE: ActionScript 3 developers will also notice that there is an additional parameter named clip which passes a reference to the DisplayObject container for your ad to appear. This is required, and by default this is set to root for pre-game and inter-level ads. See below for more info regarding customizing this parameter.

Pre-game Ad:

To add a pre-game ad with a preloader to your game, simply get the appropriate in-game code from the Mochi Developer web site, and paste it into the main timeline of your movie, in the place you've designated for a preloader (fig.c).

If your game is ready, you can test your movie, and you should see the pre-game ad appear as your movie loads. You may test your ads as much as you like while you develop your game. Keep in mind that your ads will not earn money until you complete your game profile which includes a URL to the completed game. You may also upload your SWF file from the Game Settings page for free hosting.

Inter-level Ad

To add an inter-level ad to your game, simply get the appropriate code from the Mochi Developer web site, and paste it into the main timeline of your movie, in the place you've designated for your inter-level screen (fig.d).

Just like the pre-game ad, you can test your game and see the inter-level ads in action.

Click-away ad

To add a Click-away ad to your game, simply get the appropriate code from the Mochi Developer web site. Pass in the DisplayObject container / MovieClip which will contain the Click-away ad in the clip parameter. The upper left corner of the 300x250 Click-away ad will be placed at the upper left corner of the DisplayObject container / MovieClip you specify. When you wish to stop displaying the Click-away ad pass your clip to MochiAd.unload() depending on your respective ActionScript version publish settings.

You must assign a MovieClip? to the clip parameter when using a Click Away ad. The reason you must do this is so our Ads API knows where to put the Click Away ad in your game. If you didn't do this, we wouldn't know where to put the ad. Should it appear in your main menu? On your game's stage? Inside an inventory window? On top of the avatar's head?

NOTE: The easiest thing to do is create an empty MovieClip?, name it appropriately like clickAwayAdMovieClip and place it somewhere on your stage. This is now the clip you assign to the Click Away ad clip parameter.

Showcase and Dock Ads (AS3 ONLY)

Two new ad methods were introduced with version 4.0 of the MochiAds API. These methods are AS3 ONLY!

To add a showcase or dock type to your game, use the example code below. The Showcase or Dock will display a row or column of ads in a rectangle.

A game can contain one Showcase and one Dock ad which will remain available for the duration of the game, but can be hidden or revealed by calling the appropriate methods on the API. See specific methods below.

You must assign an empty MovieClip to the 'clip' property when using a Showcase or Dock ad. This MovieClip instance must be above all other game assets in the display list and must be positioned at the top left corner of the game area. (0,0)

Showcase Ads

The API call will load a Mochi Showcase Ad into the clip. The Showcase loads a number of small, static ads into a horizontal row of thumbnails, and by default centers it in the game area with an optional 'close' button.

To load a Showcase Ad make a call to the MochiAds API using the example code below:

import mochi.as3.*;
// This clip must be above all other game assets in the display list and must be positioned at screen coordinate (0,0)
var clip:MovieClip = new MovieClip();
var game_id:String = "REPLACE WITH YOUR GAME ID";

MochiAd.loadShowcase({
    clip:clip,
    id:game_id,
    position:"0x0", // This represents an X, Y offset from the center.
    ad_count:5, // The number of ads to display in the showcase. (Choose a lower number for small games)
    ad_size:90, // Force dimensions for all Ads displayed.
    user_close:true, // Allow the use to close the Showcase ad.
    ad_loaded: function(w:int, h:int):void { }, // A callback that occurs when ad is first displayed.
    ad_closed: function():void {} // A callback that occurs when user closes Showcase.
});

Additional control methods are available to hide the Showcase and redisplay it at appropriate times (for example: between levels). These methods are :

MochiAd.openAdGroup(clip)

MochiAd.closeAdGroup(clip)

In both cases 'clip' is the MovieClip reference assigned to the 'clip' property when calling loadShowcase().

Dock Ads

The API call will load a Dock into the clip. The Dock will load a number of small, static ads into an "auto-hide" dock on one edge of the game window. The Dock is initially visible and fully extended into the game area. After a short time the Dock will retract out of view, leaving only a small mouse-over tab visible in the game area. If the user rolls the mouse pointer over the tab the Dock will extend back into view for a short time.

To load a Dock ad make the following call to the MochiAds API :

import mochi.as3.*;
// This clip must be above all other game assets in the display list and must be positioned at screen coordinate (0,0)
var clip:MovieClip = new MovieClip();
var game_id:String = "REPLACE WITH YOUR GAME ID";

MochiAd.loadDock({
    clip:clip,
    id:game_id,
    position:"bottom", // See below for explanation.
    ad_count:5, // The number of ads to display in the showcase. (Choose a lower number for small games)
    ad_size:90, // Force dimensions for all Ads displayed.
    ad_loaded: function(w:int, h:int):void { }, // A callback that occurs when ad is first displayed.
    ad_opened: function():void {}, // A callback that occurs when the user opens the Dock by mousing over the tab.
    ad_closed: function():void {} // A callback that occurs when the Dock auto-hides.
});

The location and orientation of the Dock can be selected to keep the mouse-over tab away from the gameplay area where the mouse is most active. Location and orientation are parsed from a 'position' property on the 'options' object. The available options for the value of 'position' are:

The default 'position' is "bottom" if this property is not assigned.

Additional control methods are available :

MochiAd.closeAdGroup(clip); // Hide Dock completly, including mouse-over tab.

MochiAd.openAdGroup(clip); // Redisplay hidden Dock (without opening slider).

MochiAd.openDockSlider(clip); // Cause displayed Dock to slide open.

In all cases 'clip' is the MovieClip reference used when calling loadDock().

Fitting Showcase and Dock Ads Into Small Games

The default configuration of five 90 pixel ads in a row or column may not fit in smaller games. There are two approaches you can take to work around this problem:

You can set an 'ad_size' property on the object you pass into MochiAd:loadDock() or MochiAd:loadShowcase() This will force one dimension of the individual thumbnails (width, in the case of Showcase and horizontal Docks, height, in the case of vertically oriented Docks) the default ad_size is 90 pixels, if not supplied.

You can also change the number of ads displayed in a Dock or Showcase by setting the 'ad_count' property on the object you pass into the load method. The default is 5.

Flash Player Security Settings:

If you are testing locally outside of the Flash authoring environment and want to be able to see ads, you will need to change the default local playback security settings. In Flash, go to "File -> Publish Settings," then click on the "Flash" tab. At the bottom, under "Local Playback Security", choose "Access network only" and then publish again. Keep in mind that if you are loading any local data that it will no longer be accessible until you change your settings back to "Access local files only." These settings will not affect playback on the web.

Alternatively, you may wish to add the location of your development files to your global security settings in the Adobe Flash Player Settings Manager. This way, you can give all SWF files in this location local-trusted access, allowing access to both local and remote data.

You will not need to do this if you are only testing your games in the Flash authoring environment, although you will see Sandbox Violation warnings in the Output panel. Warnings pertaining to MochiAPI can be safely ignored.

Alternate In-game Code Placement

Since there are many different ways to architect Flash games, it is very likely that your game development setup is not the same as what you see above. You may have nested MovieClips, or perhaps you are not using the timeline at all. It is possible to place your in-game code in the timeline of a MovieClip as well, and it will execute when the frame where you placed the code is reached.

And You're Done!

That's all that is required to get MochiAPI Ads running in your game. When you've completed your game and released it to the world, be sure to complete your profile so that your game can be approved and you can start earning money right away!

1.3 Customizing Your Ad

NOTE: The easiest way to customize the ads shown in your game is to use the Ad Code code generator in the developer dashboard. You can find this code generator by going to your Mochi developer dashboard, selecting your game, clicking on "Ads" on the left and then "Mochi Ads Code: Get the ad code and installation instructions" beneath the Default Ad Settings." Inside you will be provided the option to customize the options.

It is possible to customize many of the visual elements and behaviors of your Mochi Ads. The Mochi Ads API in-game code allows you to simply tailor the display to suit your needs. Here's some of the things you can tweak:

• MovieClip container: You can place your ad into any MovieClip on the stage, or into MovieClips you create with Actionscript.
• Timing: You can customize fade time of your ads.
• Colors: Change the colors of the ad preloader bar, background and outline. You can also turn off the solid background.
• Event Handlers: You can assign custom functions to be called when ads start, load, and end.

The Mochi Ads API

Your ads can be customized by sending special parameters via your in-game code. Depending on whether you've chosen to display a pre-game or inter-level ad, your options will be slightly different.

The in-game code is passed an object with keys and values to pass to the server. The default code contains two keys -- id, the unique Mochi game ID, and res, the height x width of your game. These parameters are required.

import mochi.as2.*;
MochiAd.showPreGameAd({id:"xxxxxxxxxxxxxxxx", res:"360x240"});

You may add more key: value pairs to the object by separating them with commas. You may add the following optional parameters to your object:

• clip:MovieClip - a MovieClip reference in which to place the ad. Required for click-away, showcase and dock ads or if you're using Actionscript 3.0. Otherwise the default is _root. (default: _root)
• no_bg:Boolean - setting to true allows you to disable the background entirely. (default: false)

The following additional options apply to pre-game ads only:

• color:Number - the color of the preloader bar as a number. (default: 0xFF8A00)
• background:Number - the inside color of the preloader bar as a number. (default: 0xFFFFC9)
• outline:Number - the outline color of the preloader bar as a number. (default: 0xD58B3C)
• no_progress_bar:Boolean - setting to true allows you to disable the preload progress bar. (default: false)

You can find out the width and height of your ad when it loads. You can use this information to create a custom frame around your ad that matches your game.

• ad_loaded:Function - ad_loaded is called just before an ad is displayed with the width and height of the ad. (default: function(width:Number, height:Number):Void { }).

You can also find out the progress of the preloader bar. You can use this information to create your own preloader bar when used with the no_progress_bar option.

• ad_progress:Function - ad_progress is called with the progress of the preloader bar. The progress is a percent (represented from 0 to 100). (default: function(percent:Number):Void { }).

Here is an example of how the code might look if you were to add more options:

import mochi.as2.*;
MochiAd.showPreGameAd({id:"xxxxxxxxxxxxxxxx", res:"360x240", clip: _root.myClip, no_bg: true, color: 0x006699, outline: 0xFFFFFF});

If you need to add many options, or define functions to handle ad events, you may consider creating an object first, and then referencing that object when you call the Mochi Ads API.

import mochi.as2.*;

var myOptions:Object = {
id: "xxxxxxxxxxxxxxxx",
res: "360x240",
clip: _root.myClip,
color: 0x006699,
background: 0x333333,
outline: 0xFFFFFF,
ad_loaded: function (width, height) { trace("ad loaded: " + width + "x" + height); }
ad_progress: function (percent) { trace("preloader percent: " + percent); }
}
MochiAd.showPreGameAd({myOptions});

There is also a tool on the Mochi Developer web site to customize the appearance of your ad when you set up your in-game code. Often, this is easier than editing the code by hand.

1.4 Changing Ad Behaviors

The Mochi Ads API described above also allows you to assign your own event handlers to be called by your ad. There are six events:

• ad_started:Function - a function to call when the ad has started playing. (default: function ():Void { this.clip.stop() })
• ad_loaded:Function - a function to call just before an ad is displayed with the width and height of the ad. If it is called, it is called after ad_started. (default: function(width:Number, height:Number):Void { }).
• ad_finished:Function - a function to call when the ad has finished playing. (default: function ():Void { this.clip.play() })
• ad_failed:Function - a function to call if an ad can not be displayed, this is usually due to the user having ad blocking software installed or issues with retrieving the ad over the network. If it is called, then it is called before ad_finished. (default: function ():Void { })
• ad_skipped:Function - a function to call if the ad was skipped, this is usually due to frequency capping, or developer initiated domain filtering. If it is called, then it is called before ad_finished. (default: function ():Void { })
• ad_progress:Function - a function to call when the progress of the preloader bar has changed. The progress is a percent (represented from 0 to 100). (default: function(percent:Number):Void { }).

When you assign custom functions to ad_started and ad_finished in your options object, your ad will no longer stop and play the timeline. Instead, your custom functions will be called.

import mochi.as2.*;

var myOptions:Object = {
id: "xxxxxxxxxxxxxxxx",
res: "360x240",
clip: _root.myClip,
ad_started: function ():Void { _global.game.pause(); },
ad_finished: function ():Void { _global.game.resume(); }
}

MochiAd.showPreGameAd({myOptions});

It is best to explicitly pass a function literal in your options object instead of referencing a function in a separate class. That way, you do not need to worry about losing scope or relying on the Delegate class. If you are using ActionScript 3, though, you can pass a reference to your function without losing scope.

Keep in mind that, if you define custom ad_started or ad_finished event handlers, your timeline will no longer be stopped during the playback of your ad. So, if you still wish to stop your timeline, you will need to be sure your event handler does this.

1.5 MTASC and MXMLC

For those developers who are developing in environments that don't use the Flash IDE, the process for adding the Mochi Ads API will be slightly different. In order to get your ads functioning in your game, you will need to:

1. Make sure that the mochi folder is in your root project classpath.
2. You've added the in-game code in a method that is executed in an instantiated class in your game.

1.6 Adobe Flex

To use the Mochi Ads API as an Adobe Flex application's preloader, you will need to:

1. Make sure that you use the MochiPreloader.as from the examples/flex folder from the MochiAPI ZIP package.
2. Make sure that the mochi folder and MochiPreloader.as are in your project classpath.
3. Tell your MXML application the preloader you want to use:

   <mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" preloader="MochiPreloader">
   </mx:Application>

4. NOTE: With inter-level ads, the Mochi API is unable to tell your game when it has finished via the MovieClip.stop() and MovieClip.start() methods. You must use the ad_started and ad_finished callback methods in your game's options object (described in Section 1.4) to be notified when to start and stop your game.

1.7 ActionScript 3.0 Preloader

The mxmlc folder includes a preloader class (Preloader.as) that provides an example of how to properly compile a preloader into an AS3 SWF compiled with Adobe Flex mxmlc compiler. For the preloader to function correctly, it must load first and execute before your base class and other SWF assets load. In order for this to happen, the Preloader class is included on the first frame of your SWF and all of the other assets are included on the next frame. The Preloader class contains a weak reference to your document class that it uses to instantiate your class after it completely loads your game.

// Change this class name to your main class
public static var MAIN_CLASS:String = "Test";

For Flex Builder, there is a makefile included in the example which tells the mxmlc compiler to include your Document Class in the second "frame" of your SWF so that the preloader will load first:

mxmlc \
           -default-frame-rate 31 \
           -default-size 550 400 \
           -use-network \
           -optimize=true \
           -output $@ \
           -frame=Test,Test \
           Preloader.as

Notice the compiler option '-frame=Test,Test'.

If you are using FlashDevelop, you need to make sure you're passing "-frame Test, Test" to the mxmlc compiler, which you can set under Compiler Options in Project Properties. Don't forget to change 'Test' to the actual name of your base class.

1.8 Flash Develop

Our example uses the AS3 Empty Project Template as it's basis. Using our API within this framework is no more difficult than that of a standard Flash IDE project. Simply copy the mochi folder into the src folder created for your project. After you have done this, it is simply a matter of using that standard API calls

1.9 More Resources

If you have questions about using the Mochi Ads API, you can view our FAQs or visit the support forums for help. Also, if you have suggestions regarding this help document, we encourage your feedback.

1.1 Overview

Our Live Updates service enables you to create a special version of your SWF which can be updated at any time and contains an extra layer of encryption to protect against decompiling.

Benefits of Mochi Live Updates

• Update anything about your game, at any time. The updated version will be instantly available to players around the world.
• The game does not require Mochi servers to be played – Your file is completely stand alone.
• Your game can be played offline as well as online – Offline players simply get the original packaged version
• Increased encryption and protection from decompiling.
• Downloading the new updates are quick and transparent, players only need the differences between versions.

Live Updates works great for

• Fixing those nasty bugs that crop up after your game is released.
• Recently changed your logo? No problem, upload a new version with a new splash screen.
• Made a hot new sequel to your game? Add in a link and screenshot pointing users to the sequel to generate awareness and traffic.
• Sell a timed sponsorship to someone for a fixed period of time. Simply upload the new version with their links and splash screen and revert to the old version when you're done.

How it works

Live Updates games play just like any other game to the user. However behind the scenes when the game is first loaded it checks with Mochi servers to see if there is a new version available. If so, the game will be patched while during the loading process (it only sends minimum differences, so it doesn’t have to download the whole game over again).

1.2 General Installation

Adding a new game

1. Click on 'add game' like normal to add a game to the Mochi service.
2. Check the box 'Use Live Updates' to enable the feature.
3. Add a verification code to your game - this ensures you have access to the source code.
4. Upload your game, a pre-loader is automatically added so you don't have to include any ad-code for a pre-loader. Other in-game ad formats are ok.

Updating your game

1. Click on your game from your developer dashboard.
2. Click on the 'game settings' link
3. Under the 'game files' section, click on 'upload new version'.
4. Select 'use Live Updates' for the new game version.
5. Follow the on-screen instructions and upload your new version.

That's it!

Distribute your new version anywhere you like! If at any time you want to change your game, visit your game settings tab and upload the new version. Within minutes players will be enjoying your new awesomeness.

1.3 Test Your Game For Compatibility

The Live Updates service embeds games into an AS3 loader SWF. The Flash Player treats games differently when loaded this way than when loaded by either through an HTML page or directly into a browser.

To test for compatibility, loading your game using the LoaderTest utility to see if you can reproduce the problem. LoaderTest uses the same underlying Flash features that the Live Updates loader SWF uses. If the problems are still present when using LoaderTest, then you will need to make changes to your game. If the problems are not present, then notify us, and we will investigate the problem.

1.4 Preparing AS3 games

AS3 display list membership

Adobe’s Flash Player treats AS3 SWFs loaded into another AS3 SWF differently than when it’s loaded directly by the browser. In particular, the main object is not added to the display list until after the constructor is called whereas when loaded directly the main object is already attached to the display list. This results in the stage and parent properties being set to ‘null’ (and likely resulting in null object references).

This can usually be worked around by moving any code that needs to interact with the stage being moved to an event listener. Event.ENTER_FRAME, Event.INIT, or Event.ADDED_TO_STAGE events are good candidates for this.

AS3 LoaderInfo, third party APIs

Since Live Updates loads your code with a flash.display.Loader, the FlashVars and URL should be accessed somewhat differently than normal. Some third party APIs may need small changes to use this LoaderInfo instead of root.loaderInfo. This code will get the true LoaderInfo in a game using Live Updates (but also works if not using Live Updates):

public function getMainLoaderInfo():LoaderInfo {
    var loaderInfo:LoaderInfo = root.loaderInfo;
    if (loaderInfo.loader != null) {
        loaderInfo = loaderInfo.loader.loaderInfo;
    }
    return loaderInfo;
}

1.5 Preparing AS2 games

1.6 Preparing AS1 games

Case-sensitivity: Users have reported that AS1 games loaded into AVM1Movie are suddenly case sensitive, whereas normally they are case-insensitive.

1.7 Third Party APIs written in AS2

Usually these APIs work by cross-scripting a SWF to inject new code into AS2 games. However, Flash does not support cross-scripting between AS2 and AS3, and the Live Updates loader SWF uses AS3, preventing the API from being injected correctly.

NOTE: LocalConnection APIs will still work, but sites may not provide these for AS2.

1.8 Flash 10 games using TLF Text (Text Layout Framework)

TLF Text causes your SWF file to be wrapped in an additional preloader, which is not compatible with Live Updates. The workaround is to follow "Solution 1" in this Tech Note: http://kb2.adobe.com/cps/838/cpsid_83812.html

Go to "File" -> "ActionScript Settings" and then change "Default linkage" to "Merged into code". This will allow SWFs with TLF text to be used with Live Updates.

1.9 Flash Player targeting options

You can select the version of Flash Player that you would like to target, starting from Flash Player 10 and continuing through to the latest version. There is a drop-down menu in the Live Updates settings page, which is accessible both when uploading a new game (and selecting Live Updates) and the Live Updates settings for an existing game. Simply select the Flash Player version you would like to target from this menu.

1.1 Overview

MochiServices is all Mochi APIs except for the Mochi Ads API. The API is dynamically loaded from Mochi servers and must be initialized in either the first frame of your game or during Document Class initialization.

NOTE: The easiest way to start implementing Leaderboards is to do so through the developer dashboard. First go to the Mochi developer dashboard, select your game, click on Scores and then click on Create Leaderboard. After you fill in the appropriate information, you will see a list of all your leaderboards. Click "Actionscript Code" to find step by step instructions on how to use the leaderboards!

1.2 Prerequisites

MochiAPI is not compatible with versions prior to Flash Player 9, and is no longer compatible with ActionScript 1.0.

Installing the Mochi Scores API

1. Download and unzip the latest MochiAPI.
2. Copy the “mochi” folder and paste it into the root classpath of your game. Most often this is the same as the location of your game’s FLA file.

NOTE: In the 3.0 revision of the API, we changed namespaces for our libraries to unify and organize our packages. Now you must explicitly call the MochiAPI that is specific version: mochi.as2.* or mochi.as3.* respectively. For the purposes of this documentation we will show examples specifying the ActionScript 2.0 API. Simply change mochi.as2. from the code samples, and add import mochi.as3.*; to the beginning of your code block to use the ActionScript 3.0 API.

1.3 Connecting to MochiServices

Leaderboards

MochiEvents Achievements API

MochiDigits

Link Tracking API Documentation