Casual Game Development
Hooks and Closures
http://blog.pettomato.com/?p=18

One design idiom that I have borrowed from Emacs Lisp is the concept of hooks. A hook is a function that's called when a particular event happens. In Emacs, for example, whenever I create a new file, I have a hook that checks if the file ends in ".as" and if it does, I automatically add some boilerplate code to the file (constructor, toString, etc). In a game, you could have a set of hooks that fire whenever a collision takes place, a timer runs out, a room is entered, etc. Any number of hooks can be added to an event and they are run in the order they were added. They can also be added/removed at runtime.

Below is a simple utility class, Hook.as, that provides two functions for working with hooks. The first function returns a new function that can be used to add hooks to an event. The second one returns a function that will run all the hooks that have been added.

Hook.as

ACTIONSCRIPT
1. class standard.Hook{
2.  
3.   private function Hook(){
4.     // We never instantiate this class.
5.   }
6.  
7.   static public function MakeAddHookFunc(a:Array):Function{
8.  
9.     var f = function(new_func:Function,bOverwrite:Boolean){
10.       // The list of hooks can be cleared by sending new_func=null
11.       // and bOverwrite=true.
12.  
13.       // bOverwrite=true means to remove any previous hooks before
14.       // adding new_func.
15.  
16.       if(bOverwrite == true){
17.         // If we set a to a new [], then it becomes a different
18.         // array than the one we used with MakeRunHooksFunc. Therefore,
19.         // we instead set the length to 0.
20.         a.length = 0;
21.       }
22.  
23.       if(new_func != null){
24.         a.push(new_func);
25.       }
26.     }
27.  
28.     return f;
29.   }
30.  
31.   static public function MakeRunHooksFunc(a:Array):Function{
32.  
33.   // Returns a function which, when called, will call each of the functions
34.   // in 'a'. You can call the function with any number of arguments as long as
35.   // the functions that you added to 'a' can take those args.
36.  
37.   // *Note that the array that you pass to this function should be the same
38.   // exact array that you used with MakeAddHookFunc.
39.  
40.   var f = function(){
41.     var N = a.length;
42.     for(var i=0;i<N;i++){
43.       a[i].apply(null, arguments); // apply is used so that we can pass any number
44.                                    // of arguments to this function.
45.       }
46.     }
47.  
48.     return f;
49.   }
50.  
51.   public function toString(Void):String{
52.  
53.     return "Hook()";
54.   }
55. }

The second class, Simple_Button.as, is something that I use in a lot of places to give button behaviors to MovieClips. It uses the functions in Hooks.as to create hooks for button events and for disabling/enabling the button. For a button press event, I might add one hook to change the button graphic and a second hook to do whatever action the button should perform.

Simple_Button.as

ACTIONSCRIPT
1. class standard.widget.Simple_Button extends standard.widget.Widget{
2.  
3.   private var _enabled:Boolean;
4.  
5.   private var RunEnableHooks:Function;
6.   private var RunDisableHooks:Function;
7.  
8.   public var AddEnableHook:Function;
9.   public var AddDisableHook:Function;
10.  
11.   public var AddMouseDownEvent:Function;
12.   public var AddMouseUpEvent:Function;
13.   public var AddRollOverEvent:Function;
14.   public var AddRollOutEvent:Function;
15.  
16.   private var OnMouseDown:Function;
17.   private var OnMouseUp:Function;
18.   private var OnMouseOver:Function;
19.   private var OnMouseOut:Function;
20.  
21.   static private var COUNT:Number = 0;
22.  
23.   function Simple_Button(parentMC, bCreateMC:Boolean){
24.  
25.     super();
26.  
27.     if(bCreateMC == null ||
28.        bCreateMC == true)
29.         Create_MC(parentMC);
30.  
31.     var enable_hook_ar  = [];
32.     var disable_hook_ar = [];
33.  
34.     AddEnableHook     = standard.Hook.MakeAddHookFunc(enable_hook_ar);
35.     RunEnableHooks    = standard.Hook.MakeRunHooksFunc(enable_hook_ar);
36.  
37.     AddDisableHook    = standard.Hook.MakeAddHookFunc(disable_hook_ar);
38.     RunDisableHooks   = standard.Hook.MakeRunHooksFunc(disable_hook_ar);
39.  
40.     var mouseDownEvent_ar = [];
41.     var mouseUpEvent_ar   = [];
42.     var mouseOverEvent_ar = [];
43.     var mouseOutEvent_ar  = [];
44.  
45.     AddMouseDownEvent = standard.Hook.MakeAddHookFunc(mouseDownEvent_ar);
46.     AddMouseUpEvent   = standard.Hook.MakeAddHookFunc(mouseUpEvent_ar);
47.     AddRollOverEvent  = standard.Hook.MakeAddHookFunc(mouseOverEvent_ar);
48.     AddRollOutEvent   = standard.Hook.MakeAddHookFunc(mouseOutEvent_ar);
49.  
50.     OnMouseDown = MakeMouseEventFunc(mouseDownEvent_ar, _mc);
51.     OnMouseUp   = MakeMouseEventFunc(mouseUpEvent_ar, _mc);
52.     OnMouseOver = MakeMouseEventFunc(mouseOverEvent_ar, _mc);
53.     OnMouseOut  = MakeMouseEventFunc(mouseOutEvent_ar, _mc);
54.  
55.     _enabled = true; // will be set to false, immediately.
56.  
57.     Enable(false);
58.   }
59.  
60.   public function Enable(b:Boolean):Void{
61.  
62.     // Call Enable(true) to enable the button, and Enable(false) to
63.     // disable it. If the button is already in the desired state, then
64.     // the request will be ignored.
65.  
66.     if(b){
67.  
68.       if(!_enabled){
69.  
70.         _enabled = true;
71.  
72.         _mc.onPress          = OnMouseDown;
73.         _mc.onRelease        = OnMouseUp;
74.         _mc.onReleaseOutside = OnMouseUp;
75.         _mc.onRollOver       = OnMouseOver;
76.         _mc.onRollOut        = OnMouseOut;
77.  
78.         RunEnableHooks();
79.       }
80.     }
81.     else{
82.  
83.       if(_enabled){
84.  
85.         _enabled = false;
86.  
87.         delete _mc.onRelease;
88.         delete _mc.onPress;
89.         delete _mc.onReleaseOutside;
90.         delete _mc.onRollOver;
91.         delete _mc.onRollOut;
92.  
93.         RunDisableHooks();
94.       }
95.     }
96.   }
97.  
98.   public function IsEnabled(Void):Boolean{
99.  
100.     return _enabled;
101.   }
102.  
103.   static private function MakeMouseEventFunc(a:Array,mc:MovieClip):Function{
104.  
105.     // This is just like Hook.MakeRunHooksFunc, but we are assuming that all the
106.     // mouse event hooks are going to take the current mouse x and y positions
107.     // the only arguments. *I don't really like this, but I need it right now
108.     // to support legacy code.
109.  
110.     var f = function(){
111.  
112.       var x = mc._xmouse;
113.       var y = mc._ymouse;
114.  
115.       var N = a.length;
116.       for(var i=0;i<N;i++){
117.         a[i](x,y);
118.       }
119.     }
120.  
121.     return f;
122.   }
123.  
124.   public function toString(Void):String{
125.  
126.     return "Simple_Button()";
127.   }
128. }

Here is some example code that I used to create three buttons for selecting a character in a game:

Example Usage

ACTIONSCRIPT
1. private function CreateButtons(Void):Void{
2.  
3.   var buttons = [];
4.  
5.   for( var i=0;i<3;i++ ){
6.  
7.     var b = new Simple_Button(_mc);
8.  
9.     buttons.push(b);
10.  
11.     var b_index = i + 1;
12.     var b_mc = _mc["characterMC" + b_index];
13.  
14.     b.AddMouseDownEvent(MakeMsgFunc(_fsm,MSG_ChangeState,300,{index: b_index}));
15.     b.AddMouseDownEvent(MakeMCFrameFunc(b_mc,"down",true));
16.     b.AddMouseDownEvent(MakePressButtonFunc(buttons));
17.     b.AddRollOverEvent(MakeMCFrameFunc(b_mc,"over",false));
18.     b.AddRollOutEvent(MakeMCFrameFunc(b_mc,"off",false));
19.  
20.     b.Enable(true);
21.   }
22. }
23.  
24. static private function MakeMsgFunc(sending_fsm:StateMachine_NEW,msg_type:Number,delay:Number,data:Object):Function{
25.  
26.   if(delay == null)
27.     delay = 0;
28.  
29.   var f = function(){
30.     sending_fsm.SendDelayedMsgToMe(delay,msg_type,SCOPE_TO_THIS_STATE,data);
31.   }
32.  
33.   return f;
34. }
35.  
36. static private function MakePressButtonFunc(button_ar:Array):Function{
37.  
38.   var f = function(){
39.  
40.     // disable all buttons
41.     for(var i in button_ar)
42.       button_ar[i].Enable(false);
43.   }
44.  
45.   return f;
46. }
47.  
48. private function MakeMCFrameFunc(mc:MovieClip,label:String,bPlay:Boolean):Function{
49.  
50.   var f;
51.  
52.   if(bPlay){
53.     f = function(){
54.       mc.gotoAndPlay(label);
55.     }
56.   }
57.   else{
58.     f = function(){
59.       mc.gotoAndStop(label);
60.     }
61.   }
62.  
63.   return f;
64. }

This might seem convoluted at first, but the best part is that everything only does one thing. One of the main goals of functional programming is that there are (nearly) no side-effects. Notice that there's no "owner" or "parent" crap in any of the buttons. Also, notice that "buttons" is a local variable, but all the functions that you create with MakePressButtonFunc will always keep a reference to it, even when it passes out of scope. That's the "closure" that Actionscript and Lisp can do that many languages can't. Lisp advocates think that it's one of Lisp's most important features.

I'm not sure about the implementation in Flash, but in Lisp there are not any performance issues with creating all those functions, because it isn't like creating a new object. The "new" functions are actually very similar to the methods of a class. That's why you don't have to say "var f = new function." Also, the closures have those passed-in variables bound to them, so they might even be faster than "owner.doSomething()" which has to look up "owner" and then call the function.

Anyway, for me, this stuff has solved a lot of problems that I've dealt with in the past and I've been able to reduce a lot of my code significantly.

Via FeedShow.com