Having a SAVE feature in a project/game is one of the common things that could lead users to be more attracted and increase replay value for potentially recovering what was done in a previous visit. Using the SharedObject class in actionscript project/games is sometimes a requirement or at least a need, may it be AS1 (FP6), 2 or 3. It can be used to store valuable data like progress, settings, statistics, achievements and a lot more without dedicating storage on the server. Basically, SO or shared objects are like the browser cookies for flash, it is used to store some amount of data on the user machine, therefore it also has some limitations on its use (for security purposes really).

By reading the documentations or the livedocs, either for AS2 or AS3 (it’s really the same), you might have a gut start of what key points to remember.

• created shared objects can only be stored/retrieved on the same domain
• shared objects cannot be shared across domains, meaning a shared objects from “examplesite.com” cannot read shared objects created by another domain “mywebsite.com”
• users can disallow local storage per domain or opt-out globaly, then the object would not be saved locally
• data size to be stored is limited by which the user sets it (none, 10kb, 100kb, 1mb, 10mb, unlimited), although a dialog box can request an increase in storage if what is set is exceeded
• if the user sets a limit smaller than the shared object, the shared object would be deleted
• shared objects are stored on the user’s local machine not on the server, something shared over another machine cannot be accessed by another machine

The most essential part when using SharedObject is the SharedObject.getLocal() method, which is what we will be discussing more through out. Basically, AS1/2 and AS3 syntax haven’t really changed (although a few more rules were imposed in as3).

getLocal(name:String, localPath:String = null, secure:Boolean = false):SharedObject
[static] Returns a reference to a locally persistent shared object that is only available to the current client.

var mySo:SharedObject = SharedObject.getLocal( 'mySaveName', localPath, secure );
mySo.data.thingtoSave = myVariable; // your variables
mySo.flush(); // stores data into disk

Avoiding Known Issues

It might seem that using shared objects could be the simplest when you are only storing a couple of variables and objects like statistics or even could be the more complex when saving a game progress/state together with the players preferences. The bigger the system, more likely, the more complex your variables/objects are (same for games), and this is where possible issues during saving/loading/handling the shared objects.

Some common things to remember when using shared objects with your games:

1. Don’t use direct reference to objects and use the game’s data only not the actual game objects.
2. Use a localPath param on the getLocal() method.
3. Taking advantage of unique names for your shared object name.
4. Prompt and request for shared object size limit increase when your game needs it.

While I only have these that I can explain, you are free to share more if you have one or more. We can discuss and make the lives of other actionscript writers a little better.

Don’t use direct reference to objects and use the game’s data only not the actual game objects.

Why do I say this? Basically it is fine to store various data types such as objects and arrays on SO (shared objects), same goes for strings, numbers (int/uint), booleans and bytearray (as3). If you store references to local game objects on your shared objects, one way or another, your in for a later problem.

var mySo:SharedObject = SharedObject.getLocal( "mySaveName" );
// world.gameObject contains further objects like settings, player, etc
mySo.data.gamedata = world.gameObject;
mySo.flush();
// --

When you do something like the above, instead of storing the needed values only, you are referencing the local game object (w/c also contains references to other local game objects) in which Flash defines this as a copy of the local object but is really just a reference. Any change through out the game values/data would update the local object (which the shared object references) and Flash Player would write that into the shared object file when flush() is called or as soon as the shared object session ends – that is then swf file is closed.

The worst case here is that when you clear, reset or even delete your local game objects, the shared object which references to it will be affected and updated (as session has ended).

Also, even if don’t experience the possibility of issues when you do the above there, a problem might still arise when you load the shared object in later time. This case might not be so common but is possible to experience if loading the shared object is sloppily made. You can have inconsistent object references where the object contained within loaded shared object is conflicting, a duplicate, or not referencing the correct object.

A better and safest way of using shared objects (something like):

mySo.data.gamedata = {
  player:{
    score: world.gameObject.player.score,
    health: world.gameObject.player.health,
    currentLevel: <code>world.gameObject.player.currentLevel
  },
  settings:{
    mute: world.gameObject.settings.mute,
    quality: world.gameObject.settings.quality,
    particles: world.gameObject.settings.particles,
  }
}
/* well this is just a shortcut on containing them into objects,
 * but the point here is that score, health, currentLevel, etc
 * are all basic data types like number/int/uint, string, bool, etc</code>

Now you see that we store each valuable data only. We now transfer only the value of the variable not it’s reference. So while it’s fine to use objects and arrays on your shared objects, keeping be wary of how you do it, be careful.

You probably wouldn’t want to directly store instances of display objects, bitmapdata, functions, etc on share objects.

Use a localPath param on the getLocal() method

While passing the localPath parameter upon calling getLocal() is optional, although I would have to recommend using it by this time. In the case where you are building an independent system, prototypes, does not consider expansion/addons and will never be a part of a larger system, you can probably opt-out the localPath and never mind it.

So whats the issue of using and not using the localPath? By default, if you leave localPath by it’s default (null), it would use the the full path of the swf file (w/c includes the swf file itself) to store your shared objects.

#SharedObjects/<random code>/<domain>/<path>/<swf filename>.swf/<object name>.sol

• Windows XP and Vista:
  • For Web sites: %APPDATA%\Macromedia\Flash Player\#SharedObjects\<random code>\<domain>\<path>\<object name>.sol
  • For AIR Applications, %APPDATA%\<AIR Application Reverse Domain Name>\Local Store\#SharedObjects\<flash filename>.swf\<object name>.sol

• Mac OS X:
  • For Web sites, ~/Library/Preferences/Macromedia/Flash Player/#SharedObjects/<random code>/<domain>/<path from webserver>/<object name>.sol
  • For AIR Applications, ~/Library/Preferences/<AIR Application Name>/Local Store/#SharedObjects/<flash filename>.swf/<object name>.sol
• Linux/Unix:
  • ~/.macromedia/Flash_Player/#SharedObjects/<random id>/<domain>/<path>/<flash filename>.swf/<object name>.sol

-taken from wiki

For example, I have a swf  at http://example.com/games/uploads/supergame.swf, and when it creates a shared object (SharedObject.getLocal("supergameData");), the SO can be found at #SharedObjects/<random code>/example.com/games/uploads/supergame.swf/supergameData.sol.

While it works well and fine without the localPath parameter, there are certain sites/APIs/services that change the game’s file name by using their automated uploads, feeds, etc as the file name is used in the path. When the developer tries to upload a bug fixed build (v1.0.1), the swf might have another file name hence a problem appears where the previous build’s (v1.0.0) shared object won’t be accessible from the new build due to security reasons.

Although your shared object would be secured against any another swf so it can’t read it, by setting a localPath parameter like “/games” or simply “/”, the shared object can now be read by another swf file within the same domain. Using “/games” would make the SO accessible for any swf within the game directory, while having “/” would make it accessible from any swf within the domain.

Again from the same example but using SharedObject.getLocal("supergameData","/");, makes the SO at #SharedObjects/<random code>/example.com/supergameData.sol. This would make it not dependant on the swf’s file name.

Note: If you set a localPath in which the path doesn’t physically exists as a (sub) directory of the domain the shared object won’t be stored. Luckily with AS3 you’ll be prompted with an Error #2134 when the SharedObject can’t be created, but for AS2, you have to be well aware of this.

Taking advantage of unique names for your shared object name

This is one is something that I have just learned through experimentation and will soon incorporate on my next projects. While setting the localPath parameter to “/” makes the SO accessible to other swfs, there is also a risk that your SO name might be the same with another swf. We wouldn’t want another swf to mess up or overwrite our SO file just because it both uses general and/or generic SO names like “saveData” or “gameData“.

The ultimate tip: Since the SO names allow certain special characters like / (slash), we take advantage of that! Together with the localPath “/”, what I recommend is do a standard setup for your SO names something like:

<company/developer name>/<game name>/<data name>

var mySo:SharedObject = SharedObject.getLocal( "jaycsantos/neolithic/preferences", "/" );
// -- and/or something else like
var mySo:SharedObject = SharedObject.getLocal( "jaycsantos/neolithic/gameData1", "/" );
// --

…will store your SO at something like: #SharedObjects/<random code>/<domain>/#jaycsantos/neolithic/gameData.sol

Although I still have to confirm this with Mac OS and Linux machines. Drop me a line if you find it working with those.

Now ain’t that a little more organized than having all SO on the “/” of the domain!

Prompt and request for shared object size limit increase when your game needs it

There are cases when your shared object has a lot of data in it and it could exceed the default 100kb limit of a user. If this happens, it may cause your shared objects to be written but not read. I have read quite a few times where issues of reading/writing of share objects were resolved by prompting a request to increase local storage limit. This is where the flush() method takes it stand.

Immediately writes a locally persistent shared object to a local file.
AS3
flush(minDiskSpace:int = 0):String

minDiskSpace:int (default = 0) — The minimum disk space, in bytes, that must be allotted for this object.

AS2
flush([minDiskSpace:Number]):Object

minDiskSpace:Number [optional] – An integer specifying the number of bytes that must be allotted for this object. The default value is 0.

With AS3, the flush() method basically does the same thing as with AS2 including their parameters, the only difference made was their return values. AS3 returns a string constant but AS2 returns an object; still their purpose is the same, only the data types have changed.

var mySo:SharedObject = SharedObject.getLocal( 'mySaveName', localPath, secure  );
mySo.data.thingtoSave = myVariable; // your variables
/* stores data into disk and require 10kb of min space
 * if the allocated disk space for local storage is
 * less than 10bk which most probaly be 1kb, then it
 * would prompt a dialog box requesting for an increase
 */
var fushResult:Object = mySo.flush(10000);
trace( fushResult );

So saying simply, if you know your game’s shared object will be greater than a few kbs, you should consider using flush(minDiskSpace) with as your expect maximum size for your data. Why maximum? – think of it as your allowance. Now don’t even consider 2mb or more as an allowance if it’ll never even reach it, play your game at it’s fullest and see what is the size of the shared object using the getSize() method (as2) and the property size (as3) then add around 5-10% of it’s size for an allowance.

Conclusion

After all I have read about using SharedObject is as simple as it could be, in reality it can be a whole lot more than spinning circles for all of what you would need. Well yes, storing a string and recovering it is a piece of icing but storing a complete game state/progress is a new kind of cake to bake. Basically what I have written here are tips and suggestions that I have experienced and with what I have experimented. Either it be accurate or I know not, using SharedObjects has its own work around and is not as simple as most people have said like building a chair, while yes it is not the most complicated but it could be a big question mark on the head for someone new or not familiar to its purpose. I might even consider making a SaveManager or the like but that would be when I get to it. Well, that’s it, this one is quite long but I know it’ll help!

Other Keywords

• Working with Flash Actionscript Shared objects.
• Issues and techniques with Flash Actionscript shared objects.
• Saving data with action script using shared objects.
• Actionscript tips and tricks, shared objects.
• Shared object help, actionscript 2 & actionscript 3.
• Flash actionscript saving & loading locally.
• Flash Actionscript proper way of use when Shared Object does not work.

Some common but usually neglected things you might not want but your game might have:

• The everlasting suggestion of “avoid directly referencing _root“.
• Yellow boxes appear (on buttons/movieclips) when pressing Tab.
• Cheating by pressing Space when the yellow boxes focus on buttons/movieclips.
• Cheating by right clicking (shows the context menu, a cheat for some game genres).
• Cheating/altering game play/screens by pressing forward, back, etc from the context menu.

_root or no _root

_root ?

As you might have read a dozen or countless times, it is highly recommended to not directly call _root within the project, although using _root is not necessarily wrong. These developers come to use _root as a hack way of referencing an absolute path to their objects. If you are building an independent system, prototypes, does not consider expansion/addons and will never be a part of a larger system then it would be fine to use _root as a hacky way. But if your work is part of a larger system or the like consider having to add in various (most of the time, 3rd party) extensions, plugins, services, APIs (application programming interfaces), SDKs (software development kits), or anything similar in it’s purpose then you’ll be in for some serious headaches. Most notable of these are those that wrap your game within another swf file. You might be able to face serious issues and problems varying from sounds not playing/missing, disposition world objects, localtoGlobal/globaltoLocal miscalculations, undefined object property, sprites (movieclips) not following the expected position and behavior, wrongly positioned custom cursors and a lot more.

// somewhere in the timeline...
_root.mySuperFunction = function(){
  // doing some super things
  return 'my super function worked!';
}
 
// somewhere else in the game...
trace( _root.mySuperFunction() );
// before
  // outputs: my super  function worked!
// after some integration and browser testing...
  // outputs:         (its really has no output)
// nooooo!!! it isn't working now! but it used to work before,
// maybe this thing wrecks my game when I use it!? I didn't do anything else.

Although I won’t be discussing fixes for the issues mentioned above, we can start by doing what is recommended, to not directly reference from the _root. The most starter’s way from first look at the documentations and other sources, is using _lockroot. Basically it could prove to be a good way to fix and keep things the same but for some cases it might not be enough. For more assurance and better practice I would recommend referencing _root from a global variable or static variable from a class (most recommended).

Why do I have to use a variable? So what we reference can be dynamic – there are some cases where the _root is not technically the parent most, where it can be a specific game container or something similar, this way you don’t have to shift through using _root and updating all your codes when needed. And the sole reason is for code reusability.

// probably on frame1 before your preloader code
this._lockroot = true; // where this = root actually
this.mySuperFunction = function(){
  // doing some super things
  return 'my super function worked!';
}

// for those who do timeline coding or the like
_global.gameroot = this; // where this = root actually
 
// somewhere else through the game...
trace( _global.gameroot.mySuperFunction() ); // output: my super function worked!
// hoorah! its working well!

// and for those who use classes (highly recommended),
// simply pass it on your main class during instantiation
// to be referenced on a static variable
var maingame = new MainGame( this ); // where this = root actually
 
// on your MainGame class or the like
class MainGame{
  public static var GameRoot:MovieClip;
  // constructor
  public function MainGame( root:MovieClip) {
    GameRoot = root; // stores the root mc in static var
  }
}
 
// somewhere else through the game...
// now simply reference from static variable MainGame.GameRoot instead of _root
trace( MainGame.GameRoot.mySuperFunction() );  // output: my super function worked!

Magical Weirdness of Yellow Boxes

Yellow Box

Some games that incorporate interactive buttons (or movieclips that acts as buttons) are not wary of this feature. Basically flash has the ability to take use of tabbing on GUI, but since we are game developers there are high chances we would not want this as it might look ugly. While most games might not be affected by this feature there are certain circumstances that the game play can be cheated one way or another. Good examples are those games that use mouse interactivity using mouse over and mouse click events, where as the player can cheat things by combining tabbing, pressing space (to select) and the use of mouse. When a yellow box appears over a button its rollOver event is triggered, and when space is pressed its onPress event is, and that is where some cheating may occur on some combinations and timing. It is fairly a simple piece of code you have to declare at the beginning to disable all of the magical yellow boxes.

// probably on frame1 before your preloader code
this.tabEnabled = false; // disable tabs for the whole movieclip
this.tabChildren = false; // disables tabs for the rest movieclip's childrens

Right clicks and Context Menus

Which frame to move?

While the context menus from right clicks (control-click for Macs) on flash can’t be removed, we can modify the menus and also strip down unnecessary movie controls like forward, back, play, etc. If your game/project is AS2 powered and is not really well structured (timeline coding and uses gotoAndStop() methods ) then you might encounter glitches and frame skips once the player right clicks and select any movie controls. They could end up skipping levels to scoring indefinitely and would make things less fun and more cheating for them.

If all you want is to simplify the menu:

// probably on frame1 before your preloader code
Stage.showMenu = false;

But if you also would like to customize and add your own menus then:

// probably on frame1 before your preloader code
// instantiate a new contextmenu
var my_cm:ContextMenu = new ContextMenu();
my_cm.hideBuiltInItems(); // hides the built in items, duh
my_cm.customItems.push( new ContextMenuItem("(c) Jayc Santos", gotoJayc) ); // creates a new menu
function gotoJayc(obj, item){ getURL("http://jaycsantos.com/"); }
this.menu = my_cm; // overwrites the default menu and where this = _root (most of the time)

There are also some cases where simply right clicking would create issues for the game play and/or cheat things. A good way to determine is to use the onSelect event. You can also use the onSelect event for more customizations of your context menus (see livedocs sample).

var my_cm:ContextMenu = new ContextMenu();
function menuHandler(obj:Object, menu:ContextMenu) {
  trace( "right click context menu was invoked" );
  // do awesome things
}
my_cm.onSelect = menuHandler;
this.menu = my_cm;

Conclusion

So overall you might probably want to have something like:

// probably on frame1 before your preloader code
Stage.showMenu = false; // hides the built in items on context menu
this._lockroot = true; // locks the root, duh
this.tabEnabled = false; // disables tabs
this.tabChildren = false; // disables tabs for it's children

for timeline coders

_global.gameroot = this; // where this = root actually
//  when "this" is traced it ouputs "_level0" most of the time unless altered

and for those who use a little more OOP approach

var maingame = new MainGame( this ); // where this = root actually
 
// on your MainGame class or the like
class MainGame{
  public static var GameRoot:MovieClip;
  // constructor
  public function MainGame( root:MovieClip) {
    GameRoot = root; // stores the root mc in static var
  }
}

Now, your actionscript 2 coding life will be a little better with these in mind.

Other Keywords

• Starting flash with actionscript 2 (AS2).
• Frame 1 of actionscript 2 project/game.
• Preloader code actionscript 2 (AS2).
• Why to avoid or why not use _root/root with actionscript.
• Getting rid of yellow boxes when tabbed.
• Flash actionscript tabs.
• Flash actionscript context menus.
• Flash actionscript important points especially for games.

Since flash player 9, site owners were allowed to take use of the additional security. You can control a SWF file’s access to network functionality by setting the allowNetworking parameter in the <object> and <embed> tags in the HTML page that contains the SWF content. It can be included by having:

<object width="100" height="100" data="sample.swf" type="application/x-shockwave-flash">
	<param name="id" value="sampleswf" />
	<param name="allowNetworking" value="internal" />
	<param name="src" value="sample.swf" />
	<param name="name" value="sampleswf" />
</object>

See your help file about this or view the livedocs (as2 or as3) discussing this added security. Basically if this ever happens to a flash game, the developer and/or sponsor are neglected of having click backs to their own sites/portals, which is not a good thing. So I made a little research and test if actionscript can determine if allowNetworking was enabled or not. This test will try to determine if external links are allowed, not exactly return the value of the allowNetworking parameter. I made a sample page here having 2 swfs (as2 & as3) embedded in different ways: using the basic embed-object tags, AC_RunActiveContent.js and swfobject class. As said in that page, the swfs on the left uses allowNetworking set to “internal” so it should say “External links disabled” and the swfs on the right doesn’t so it should say “External links ok”. Then try clicking on the links on each swf and determine if the message displayed respectively complies (either disabled or OK), if so then it pass if not then a fail. And these are the results I had (all with winXP):

In conclusion: I wasn’t successful with AS2, and to mention that the AS2 code that I used is just a trick and not legally proven in anyway. Also if you try to make a trap-like-function with your game/project/swf you should also be aware that opening external links are disabled with standalone flash players by default (which I think implements allowNetworking = “internal” with the standalone player’s sandbox). So the when the AS3 sample is ran using the standalone player you can catch the error number which will be error #0. Note: If you are using another browser which I haven’t tested or another OS, you are very much encouraged to comment out if my sample page worked properly or not with what you have.

Please read the DISCLAIMER first before you do anything with what you’ll see and learn.

Actionscript 2:

import flash.external.ExternalInterface;
 
var allowNetworking;
var str:String;
 
try{
	allowNetworking = ExternalInterface.call(null);
	str = allowNetworking +'';
	if ( str == 'null' ) {
		throw new Error("Error");
	}else{
		_root.test.htmlText = 'external links OKn"'+ str +'"';
	}
}catch( $e ){
	_root.test.htmlText = 'external links DISABLEDn "'+ str +'"';
}
 
btn.onRelease = function(){
	getURL("http://jaycsantos.com","_blank");
}

In AS2, if the ExternalInterface.call() failed it doesn’t throw an error unlike in AS3 so I have to make some workarounds with AS2 to get a return value from any possible function call and ExternalInterface.call() is my only chance. ExternalInterface.call(null) was expected to return a null value when allowNetworking is set to either “internal” or “none” and was supposed to be undefined when not. It was almost a passing code trick but IE has failed once again making the whole AS2 test a failure.

Actionscript 3:

import flash.external.ExternalInterface;
 
var allowNetworking:Object;
 
try{
	allowNetworking = ExternalInterface.call(null);
	test.htmlText = 'external links OK';
}catch( $e:* ){
	test.htmlText = 'external links DISABLEDn err #'+ $e.errorID +'';
}
 
function mouseClickHandler(event:MouseEvent):void {
    navigateToURL(new URLRequest("http://jaycsantos.com/"));
}
btn.addEventListener(MouseEvent.CLICK, mouseClickHandler);

Practically I used ExternalInterface.call(null) instead of trying to instantiate URLRequest because if it succeeds it would open up an external link and might just be blocked by a popup-blocker since the code is ran without user interaction. Unlike AS2, it will simply throw in an error when the network method is restricted.

Please read the DISCLAIMER first before you do anything with what you’ve seen and learned.

I would not recommend using any of this in a professional project or until further tests are made. But it somehow shows logic that it should work especially with the AS3 code, so use at your own risk.

The class extends the movieclip class therefore inherits all of a movieclip’s properties, methods and events. With a cursor all we would practically need is the onMouseMove event. See this custom cursor on the work from my game, Puttbase.

class MCCursor extends MovieClip {
	static var cur:MCCursor;
 
	var frame:Object;
	var onMouseMove2:Function;
 
	function MCCursor(){
		Mouse.hide();
		gotoAndStop(1);
		if ( cur ) {
			cur.removeMovieClip();
		}
		// singleton class
		cur = this;
		// swap to a very high but still safe depth
		swapDepths( 1048031 );
	}
 
	function onMouseMove(){
		_x += _xmouse;
		_y += _ymouse;
		onMouseMove2();
	}
}

Basically this is all we would need. The class is singleton (restricted to only one instance) so the instanced movieclip is stored on the static variable cur. First create a movieclip, name it whatever you want, set a linkage identifier and, most importantly, have “MCCursor” as its class (see figure below). The class may vary if you’re using a separate folder to contain all your classes but I’ll leave explaining that on another time.

Figure screenshot

To instantiate, either leave the cursor movieclip on stage during design time, where the class is instanced when the movieclip appears on stage, or attach them during run time like this:

var cur = _root.attachMovie( 'mcCursor', 'cur', _root.getNextHighestDepth() );

Now to add some other functions to make some jobs and our life easier:

This hides the mouse pionter again when the swf regains focus:

var onMouseDown2:Function;
 
function onMouseDown(){
	Mouse.hide();
	/**
	* force update position, not totally
	* necessary but might be useful somehow
	* */
	this.onMouseMove();
	onMouseDown2();
}

If you want to have your own onMouseDown event function you can use onMouseDown2 instead, so to not overwrite this method, do something like:

MCCursor.cur.onMouseDown2 = function(){
	//do what you want
}

To handle a better gotoAndStop function:

var frame:Object;
/**
* f parameter can be a number or a string (frame label),
* it will be stored on frame variable regardless
* if it is a valid frame from the movieclip or not
* */
function gotoAndStop( f:Object ) {
	super.gotoAndStop( f );
	frame = f;
}
/**
* f is a numeric value or string of the made frame label
* */
static function gotoFrame( f:Object ) {
	if ( !cur ) return;
	cur.gotoAndStop( f );
}
/**
* set getFrameNumber parameter to true to force returning the
* actual numberic value of the current frame of the movieclip
* */
static function getFrame( getFrameNumber:Boolean ):Object {
	if ( !cur ) return null;
	if ( getFrameNumber )
		return cur._currentframe;
	else
		return cur.frame;
}

For convenience, use the this static function to set the frame of the cursor and can be accessed anywhere (MCCursor class must be imported on the class to recognize it):

MCCursor.gotoFrame( f );

…have these on the class then it’s good to be used.

Grab the actual Class AS file here which also quite commented.

This is a v0.1 so it is a simple but is really expandable class. I’ll update this with new methods and features when something comes up and is necessary. An AS3 version will also be made soon.

Other Keywords:

• Change Actionscript 2 mouse cursor
• Flash mouse pointer
• Custom mouse pointer
• Personal mouse cursor
• Replace default cursor with custom mouse pointer

This is where time based coding takes place. By default, most of us amateurs went and started with frame based not knowing what it really is. When we say frame based the code and/or animation is dependent solely on how fast the FPS was set to, with a steady code, reducing the FPS rate will slow down the game and increasing it will hasten it. Time based coding can manage this quite well since everything can be dependent on time so frame rate doesn’t affect it that much. This problem is not only for games but for any development.

Code:
Let’s get started, I will discuss this with the sense of OOP approach where there is only a centralized loop function called to handle everything. I will not be actually using setInterval but the usual onEnterFrame event function.
This code is assumed to be part of a class, most cases shall be used in the main engine class but can also be used inside other classes too as long as it is correctly structured. This also assumes that the buffer movieclip is already instantiated.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

static var frameSpd:Number;
var frameTime:Number;
var buffer:MovieClip;
 
function startEngine() {
	// some more codes here
	buffer.onEnterFrame = Delegate.create( this, loop );
	// some more codes here
}
function loop() {
	frameTime = ( getTimer() - frameTime ) / 1000;
	_root.fpstxt = Math.round( 10 / frameTime ) / 10 +'fps\n '+ frameTime*1000 +'ms';
	frameSpd = frameTime / 0.030;
	frameSpd = Math.min( 2.5, frameSpd );
	var t:Number = getTimer();
 
	// more and more codes are called from here
 
	frameTime  = getTimer();
	_root.fpstxt += '\n'+ ( frameTime - t ) + 'ms';
}

Lines 1: made frameSpd a static variable so it can be easily accessed from any other location or class.

Line 11 & 19: frameTime is the time difference from when the loop was last called and ended.

Line 12 & 20: returns the frame’s FPS, last frame’s difference speed and actionscript process time.

Line 13: frameSpd is a variable that determines as a multiplier based on frameTime and the default FPS rate setting (in this case I use 30 as the movie’s FPS so 30/1000 = 0.030)

Line 14: makes a tolerance on how slow the frame rate has been and how much frameSpd has to catch up.

Implementations:
I’ll write some possible implementations in a pseudo code way using AS2 syntax and assuming that Engine is the name of the class where loop is located.

For basic movements, something like this on you movement function:

1
2
3
4
5
6
7
8
9

var spd:Number = this.speed * Engine.frameSpd;
// going left
if ( dirx < 0 ) {
	_pos.x -= spd;
// going right
} else if ( dirx > 0 ) {
	_pos.x += spd;
}
// more and more code possible here

Having gravity or other accelerating factor is quite tricky but not really too complex, something like this on your affect gravity functions:

1
2
3
4
5
6
7

// store the var locally to improve lookup speed since it is used more than once
var frameSpd:Number = Engine.frameSpd
// apply gravity or any factor with acceleration
jumpspeed += Engine.gravity * frameSpd;
// apply the speed
var spd:Number = jumpspeed * frameSpd;
_pos.y += spd;

And my favorite, handling animation speed (this one is for characters usually)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

var frameSkip:Number = Main.round( 4 * Engine.frameSpd ) + 1;
// see what current frame I am on
switch( _cframe ) {
	case 1: // stand and idle
		if ( _ccframe + frameSkip > 100 ) _ccframe = ( _ccframe + frameSkip) % 100
		else _ccframe += frameSkip;
		break;
	case 3: // run
		if ( _ccframe + frameSkip > 80 ) _ccframe = ( _ccframe + frameSkip) % 80
		else _ccframe += frameSkip;
		break;
	case 5: // jump
		if ( _ccframe + frameSkip > 65 ) _ccframe = ( _ccframe + frameSkip ) % 65 + 25;
		else _ccframe += frameSkip;
	break;
	case 7: // double jump
		if ( _ccframe + frameSkip > 50 ) {
			_ccframe = ( _ccframe + frameSkip ) % 50 + 25;
			_cframe = 5;
		} else _ccframe += frameSkip;
	break;
	default: break;
}

_cframe is the current animation frame of the character and _ccframe acts like a play head for the animation itself. If you have questions about this, my animation controller is discussed well enough on this post.

So basically having time based coding is a really powerful feature, you can even force multiply the frameSpd to a certain speed either on purposely speeding up your game or making it slow motion (matrix style). From the loop code from the top most edit it with this:

1

frameSpd = Math.min( 2.5, frameSpd ) * forceSpd;

Just make sure frameSpd maintains a tolerable value; having 10 would make it intensely fast and 0.1 would make it gruesomely slow. By default it has value of 1, 2 to make it twice and 0.5 to make half the speed, same goes if you’ll use a forceSpd.

Features:
• dependent on code, not on the swf’s framing
• very flexible and expandable
• reusable for any other animation that require distinct control
• can cheat key framing
• really simple

Structure:
Basically the primary movieclip of the character shall contain a few designated frames for each possible animation it shall have. For this case I have frame 1, 3, 5 and 7 each allocated as stand/idle, running, jump and double jump animations respectively and all have “mc” as their instance names. This is also shown on these images:

Stand MovieClip, frame 1 & 2

run MovieClip, frame 3 & 4

Jump MovieClip - frame 5 & 6

Double Jump MovieClip - frame 7 & 8

Then each animation respectively has the animation sequence tween. And take note: that each animation is not key framed with one’s or two’s yet they set on a five’s key framing. This is because our frame controller must be able to tolerate slight FPS reductions based on time (detailed on this post). So when the animation is played from the timeline during design time it would appear to be quite slower than expected.

Stand MovieClip - 100 frames

Run MovieClip - 80 frames

Jump MovieClip - 65 frames

Double Jump MovieClip - 50 frames

Also take note of each of the animation’s total frames; they’ll be used when playing through them. After setting up the structures here is where the controller comes in.

Code:
This is assumed to be within your character’s class.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

var _cframe:Number;
var _ccframe:Number;
var mc:MovieClip; // animation movieclip child
function update(){
	controlFrame();
	// some more codes here
	gotoAndStop( _cframe );
	mc.gotoAndStop( _ccframe );
}
function controlFrame() {
	var frameSkip:Number = int( 4 * Engine.frameSpd ) + 1;
 
	switch( _cframe ) {
		case 1: // stand/idle
			if ( _ccframe + frameSkip > 100 ) _ccframe = ( _ccframe + frameSkip ) % 100
			else _ccframe += frameSkip;
			break;
		case 3: // run
			if ( _ccframe + frameSkip > 80 ) _ccframe = ( _ccframe + frameSkip ) % 80
			else _ccframe += frameSkip;
			break;
		case 5: // jump
			if ( _ccframe + frameSkip > 65 ) _ccframe = ( _ccframe + frameSkip ) % 65 + 25;
			else _ccframe += frameSkip;
			break;
		case 7: // double jump
			if ( _ccframe + frameSkip > 50 ) {
				_ccframe = ( _ccframe + frameSkip ) % 50 + 25;
				_cframe = 5;
			}	else _ccframe += frameSkip;
			break;
		default: break;
	}
}

_cframe is the current animation frame of the character and _ccframe acts like a play head for the mc animation itself.

Line 11: You can see why we used five’s key framing because our frameSkip is 5 by default and is then altered by the frameSpd. So if frameSpd is not used, then the controller will basically be frame based.

Line 15 & 19: Check if the sum of frameSkip & _ccframe is greater than the total frames then use modulus (%) to reset.

Line 16, 20, 24 & 30: Else just add the frameSkip to _ccframe

Line 23 & 28: Check if the sum of frameSkip & _ccframe is greater than the total frames then use modulus (%) to reset and add a special offset specific with respect to the animation intended.

Line 29: Transfers the animation then from double jump to jump with the same _ccframe

Line 7 & 8: The update will them take care of updating the right movieclips based on what _cframe & _ccframe was changed into.