Adds ActionSequence to sprites and improved explosions in game demo

sky/sdk/example/game/lib/action.dart

 part of sprites;
 
 typedef void PointSetter(Point point);
 
 abstract class Action {
   bool _finished = false;
 
   void step(double dt);
   void update(double t) {
   }
+
+  double get duration => 0.0;
 }
 
 abstract class ActionInterval extends Action {
   double _duration;
 
   bool _firstTick = true;
   double _elapsed = 0.0;
 
   double get duration => _duration;
 
@@ skipping 25 matching lines @@
 
   ActionRepeat(this.action, this.numRepeats) {
     _duration = action.duration * numRepeats;
   }
 
   void update(double t) {
     action.update((t * numRepeats.toDouble()) % numRepeats.toDouble());
   }
 }
 
-// TODO: Implement
 class ActionSequence extends ActionInterval {
-  final List<ActionInterval> actions;
+  Action _a;
+  Action _b;
+  double _split;
 
-  ActionSequence(this.actions) {
-    for (Action action in actions) {
-      _duration += action._duration;
+  ActionSequence(List<Action> actions) {
+    assert(actions.length >= 2);
+
+    if (actions.length == 2) {
+      // Base case
+      _a = actions[0];
+      _b = actions[1];
+    } else {
+      _a = actions[0];
+      _b = new ActionSequence(actions.sublist(1));
     }
+
+    // Calculate split and duration
+    _duration = _a.duration + _b.duration;
+    if (_duration > 0) {
+      _split = _a.duration / _duration;
+    } else {
+      _split = 1.0;
+    }
+  }
+
+  void update(double t) {
+    if (t < _split) {
+      // Play first action
+      double ta;
+      if (_split > 0.0) {
+        ta = (t / _split).clamp(0.0, 1.0);
+      } else {
+        ta = 1.0;
+      }
+      _a.update(ta);
+    } else if (t >= 1.0) {
+      // Make sure everything is finished
+      if (!_a._finished) _a.update(1.0);
+      if (!_b._finished) _b.update(1.0);
+    } else {
+      // Play second action, but first make sure the first has finished
+      if (!_a._finished) _a.update(1.0);
+      double tb;
+      if (_split < 1.0) {
+        tb = (1.0 - (1.0 - t) / (1.0 - _split)).clamp(0.0, 1.0);
+      } else {
+        tb = 1.0;
+      }
+      _b.update(tb);
+    }
+  }
+}
+
+abstract class ActionInstant extends Action {
+
+  void step(double dt) {
+  }
+
+  void update(double t) {
+    fire();
+    _finished = true;
+  }
+
+  void fire();
+}
+
+class ActionCallFunction extends ActionInstant {
+  Function _function;
+
+  ActionCallFunction(this._function);
+
+  void fire() {
+    _function();
+  }
+}
+
+class ActionRemoveFromParent extends ActionInstant {
+  Node _node;
+
+  ActionRemoveFromParent(this._node);
+
+  void fire() {
+    _node.removeFromParent();
   }
 }
 
 class ActionRepeatForever extends Action {
   final ActionInterval action;
   double _elapsedInAction = 0.0;
 
   ActionRepeatForever(this.action);
 
   step(double dt) {
@@ skipping 59 matching lines @@
   }
 }
 
 class ActionController {
 
   List<Action> _actions = [];
 
   ActionController();
 
   void run(Action action) {
+    action.update(0.0);
     _actions.add(action);
   }
 
   void step(double dt) {
     for (int i = _actions.length - 1; i >= 0; i--) {
       Action action = _actions[i];
       action.step(dt);
 
       if (action._finished) {
         _actions.removeAt(i);
       }
     }
   }
 }