«
»

Actionscript Design Patterns: the Singleton

I've been wanting to write down some of the stuff that's in my head for awhile. One of the main things I've wanted to do were some tutorials.  For the most part, I've encountered two types of Flash developers at agencies.

  • Those who know design patterns, but don't want to share the information, and frequently use them to write poor code.
  • Those who are not familiar with design patterns, thought they've heard the buzz word and sometimes ignorantly criticize it.

I'd like to start off with one of the most basic patterns out there, which is also one of the most commonly used.

The singleton is simply an object, or class, that is solely limited to one instance. This same instance can be viewed by any class or object that wants to use its methods, and view it's public properties.

This comes in handy when you want to share data with multiple classes, for instance the current score on a game you're making. Without the singleton you'd have to put the score in some sort of loosely typed global object, where anything can access it and change it's values. Generally, I like to keep my code locked down, so I know which classes are accessing each other. I also like to keep as few dependencies as possible.

Let's take a look at a simple game singleton class, in Actionscript 2.0 first, then Actionscript 3.0:

PLAIN TEXT
Actionscript:
  1. class GameSingleton
  2. {
  3.     //the _instance variable is a static variable that holds the single instance
  4.     //of GameSingleton
  5.     static private var _instance:GameSingleton;
  6.    
  7.     //the score variable will only be available through getter/setters
  8.     private var _score:Number;
  9.    
  10.         //I use a private constructor so that only GameSingleton itself can create an instance
  11.     private function GameSingleton()
  12.     {
  13.        
  14.     }
  15.    
  16. /*
  17. * I use a static getter to retrieve the
  18. *_instance variable to whom ever needs it
  19. */
  20. static public function get instance():GameSingleton
  21.     {
  22.         //if this is the first time the instance
  23.         //is requested, make a new one and store it
  24.         if (!_instance)
  25.             _instance = new GameSingleton();
  26.            
  27.         return _instance;
  28.     }
  29.    
  30.     public function get score():Number
  31.     {
  32.         return _score;
  33.     }
  34.    
  35.     public function set score(val:Number):Void
  36.     {
  37.         _score = val;
  38.     }
  39.    
  40. }

Now here's the AS3 version:

PLAIN TEXT
Actionscript:
  1. package 
  2. {
  3.     /**
  4.      * ...
  5.      * @author Ryan Luce
  6.      *
  7.      * Actionscript 3 sample singleton.
  8.      */
  9.     public class GameSingleton
  10.     {
  11.        
  12.         static private var _instance:GameSingleton;
  13.        
  14.         private var _score:int = 0;
  15.        
  16.         public function GameSingleton()
  17.         {
  18.            
  19.         }
  20.    
  21.          /*
  22.           * I use a static getter to retrieve the
  23.           * _instance variable to whom ever needs it
  24.           */       
  25. public static function get instance():GameSingleton
  26.         {
  27.             //if this is the first time the instance
  28.                         //is requested, make a new one and store it
  29.                         if (!_instance)
  30.                 _instance = new GameSingleton();
  31.                
  32.             return _instance;
  33.         }
  34.        
  35.         public function get score():uint
  36.         {
  37.             return _score;
  38.         }
  39.        
  40.         public function set score(val:int):void
  41.         {
  42.             _score = val;
  43.         }
  44.     }
  45.  
  46. }

As you can see both are very similar. They both have the same implementation and use, here is an example of how I would use this in a game:

PLAIN TEXT
Actionscript:
  1. private function shotLanded():void
  2.     {
  3.     //more typically, in the constructor of any particular class,
  4.     //you would declare an instance
  5.     //such as: private var
  6.     // _gameSingleton:GameSingleton = GameSingleton.instance
  7.    
  8.         GameSingleton.instance.score += 1;
  9.     }

Singletons are used in a variety of cases, and can really help just about any flash app you are doing. They help control your data by enclosing all variable in one single instance of a class, and allowing and class in your application to access that single instance. Throw away your _global as2 reference, and use Singleotns instead! Create less dependencies by allowing data to be shared in one, none connected instance.

This entry was posted Thursday, June 3rd, 2010 at 7:45 am and is filed under Uncategorized. You can leave a response, or trackback from your own site.

Leave a Reply

things