Adds ActionSequence to sprites and improved explosions in game demo

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

 part of game;
 
 const double _steeringThreshold = 0.0;
 const double _steeringMax = 150.0;
 
 // Random generator
 Math.Random _rand = new Math.Random();
 
 const double _gameSizeWidth = 1024.0;
 const double _gameSizeHeight = 1024.0;
@@ skipping 41 matching lines @@
       addAsteroid(AsteroidSize.large);
     }
     for (int i = 0; i < 5; i++) {
       addAsteroid(AsteroidSize.medium);
     }
 
     // Add ship
     addShip();
 
     // Add starfield
-    _starField = new StarField(_spriteSheet["star.png"], _numStarsInStarField);
+    _starField = new StarField(_spriteSheet, _numStarsInStarField);
     _starField.zPosition = -2.0;
     addChild(_starField);
 
     // Add nebula
     addNebula();
 
     userInteractionEnabled = true;
     handleMultiplePointers = true;
   }
 
   // Methods for adding game objects
   
   void addAsteroid(AsteroidSize size, [Point pos]) {
-    Asteroid asteroid = new Asteroid(_spriteSheet["asteroid_big_1.png"], size);
+    Asteroid asteroid = new Asteroid(_spriteSheet, size);
     asteroid.zPosition = 1.0;
     if (pos != null) asteroid.position = pos;
     _gameLayer.addChild(asteroid);
     _asteroids.add(asteroid);
   }
 
   void addShip() {
     Ship ship = new Ship(_spriteSheet["ship.png"]);
     ship.zPosition = 10.0;
     _gameLayer.addChild(ship);
     _ship = ship;
   }
 
   void addLaser() {
     Laser laser = new Laser(_spriteSheet["laser.png"], _ship);
     laser.zPosition = 8.0;
     laser.constrainProportions = true;
     _lasers.add(laser);
     _gameLayer.addChild(laser);
   }
 
   void addNebula() {
     _nebula = new Nebula.withImage(_imgNebula);
     _gameLayer.addChild(_nebula);
   }
 
   void addExplosion(AsteroidSize asteroidSize, Point position) {
     // Add particles
-    ParticleSystem particles = new ParticleSystem(_spriteSheet["laser.png"], rotateToMovement: true,
-    startRotation:90.0, startRotationVar: 0.0, endRotation: 90.0, startSize: 0.2, startSizeVar: 0.1, endSize: 0.2, endSizeVar: 0.1,
-    numParticlesToEmit: 25, emissionRate:1000.0, blueVar: 127);
+    ParticleSystem particles = new ParticleSystem(_spriteSheet["explosion_particle.png"], rotateToMovement: true,
+    startRotation:90.0, startRotationVar: 0.0, endRotation: 90.0, startSize: 0.3, startSizeVar: 0.1, endSize: 0.3, endSizeVar: 0.1,
+    numParticlesToEmit: 25, emissionRate:1000.0, greenVar: 127, redVar: 127);
     particles.zPosition = 1010.0;
     particles.position = position;
     _gameLayer.addChild(particles);
+
+    // Add ring
+    Sprite sprtRing = new Sprite(_spriteSheet["explosion_ring.png"]);
+    sprtRing.position = position;
+    sprtRing.transferMode = TransferMode.plus;
+    _gameLayer.addChild(sprtRing);
+
+    Action scale = new ActionTween( (a) => sprtRing.scale = a, 0.2, 1.0, 1.5);
+    Action scaleAndRemove = new ActionSequence([scale, new ActionRemoveFromParent(sprtRing)]);
+    Action fade = new ActionTween( (a) => sprtRing.opacity = a, 1.0, 0.0, 1.5);
+    actions.run(scaleAndRemove);
+    actions.run(fade);
+
+    // Add streaks
+    for (int i = 0; i < 5; i++) {
+      Sprite sprtFlare = new Sprite(_spriteSheet["explosion_flare.png"]);
+      sprtFlare.pivot = new Point(0.3, 1.0);
+      sprtFlare.position = position;
+      sprtFlare.scaleX = 0.3;
+      sprtFlare.transferMode = TransferMode.plus;
+      sprtFlare.rotation = _rand.nextDouble() * 360.0;
+      _gameLayer.addChild(sprtFlare);
+
+      double multiplier = _rand.nextDouble() * 0.3 + 1.0;
+
+      Action scale = new ActionTween( (a) => sprtFlare.scaleY = a, 0.3 * multiplier, 0.8, 1.5 * multiplier);
+      Action scaleAndRemove = new ActionSequence([scale, new ActionRemoveFromParent(sprtFlare)]);
+      Action fadeIn = new ActionTween( (a) => sprtFlare.opacity = a, 0.0, 1.0, 0.5 * multiplier);
+      Action fadeOut = new ActionTween( (a) => sprtFlare.opacity = a, 1.0, 0.0, 1.0 * multiplier);
+      Action fadeInOut = new ActionSequence([fadeIn, fadeOut]);
+      actions.run(scaleAndRemove);
+      actions.run(fadeInOut);
+    }
   }
 
   void update(double dt) {
     // Move asteroids
     for (Asteroid asteroid in _asteroids) {
       asteroid.position = pointAdd(asteroid.position, asteroid._movementVector);
     }
 
     // Move lasers and remove expired lasers
     for (int i = _lasers.length - 1; i >= 0; i--) {
@@ skipping 166 matching lines @@
   double _radius;
 
   double get radius {
     if (_radius != null) return _radius;
     if (_asteroidSize == AsteroidSize.small) _radius = _smlAsteroidRadius;
     else if (_asteroidSize == AsteroidSize.medium) _radius = _medAsteroidRadius;
     else if (_asteroidSize == AsteroidSize.large) _radius = _lrgAsteroidRadius;
     return _radius;
   }
 
-  Asteroid(Texture img, AsteroidSize this._asteroidSize) : super(img) {
+  Asteroid(SpriteSheet spriteSheet, AsteroidSize this._asteroidSize) {
     size = new Size(radius * 2.0, radius * 2.0);
     position = new Point(_gameSizeWidth * _rand.nextDouble(), _gameSizeHeight * _rand.nextDouble());
     rotation = 360.0 * _rand.nextDouble();
 
+    if (_asteroidSize == AsteroidSize.small) {
+      texture = spriteSheet["asteroid_small_${_rand.nextInt(2)}.png"];
+    } else {
+      texture = spriteSheet["asteroid_big_${_rand.nextInt(2)}.png"];
+    }
+
     _movementVector = new Point(_rand.nextDouble() * _maxAsteroidSpeed * 2 - _maxAsteroidSpeed,
                                 _rand.nextDouble() * _maxAsteroidSpeed * 2 - _maxAsteroidSpeed);
 
     userInteractionEnabled = true;
 
     // Rotate forever
     double direction = (_rand.nextBool()) ? 360.0 : -360.0;
     ActionTween rot = new ActionTween( (a) => rotation = a, 0.0, direction, 2.0 * _rand.nextDouble() + 2.0);
     ActionRepeatForever repeat = new ActionRepeatForever(rot);
     actions.run(repeat);
@@ skipping 54 matching lines @@
 
   void move() {
     position = pointAdd(position, _movementVector);
     _frameCount++;
   }
 }
 
 // Background starfield
 
 class StarField extends Node {
-  Texture _img;
   int _numStars;
   List<Point> _starPositions;
   List<double> _starScales;
   List<double> _opacity;
+  List<Texture> _textures;
 
-  StarField(this._img, this._numStars) {
+  StarField(SpriteSheet spriteSheet, this._numStars) {
     _starPositions = [];
     _starScales = [];
     _opacity = [];
+    _textures = [];
 
     for (int i  = 0; i < _numStars; i++) {
       _starPositions.add(new Point(_rand.nextDouble() * _gameSizeWidth, _rand.nextDouble() * _gameSizeHeight));
       _starScales.add(_rand.nextDouble());
       _opacity.add(_rand.nextDouble() * 0.5 + 0.5);
+      _textures.add(spriteSheet["star_${_rand.nextInt(2)}.png"]);
     }
   }
 
   void paint(PaintingCanvas canvas) {
     // Setup paint object for opacity and transfer mode
     Paint paint = new Paint();
     paint.setTransferMode(TransferMode.plus);
 
-    double baseScaleX = 32.0 / _img.size.width;
-    double baseScaleY = 32.0 / _img.size.height;
+    double baseScaleX = 64.0 / _textures[0].size.width;
+    double baseScaleY = 64.0 / _textures[0].size.height;
 
     // Draw each star
     for (int i = 0; i < _numStars; i++) {
       Point pos = _starPositions[i];
       double scale = _starScales[i];
       paint.color = new Color.fromARGB((255.0*_opacity[i]).toInt(), 255, 255, 255);
 
       canvas.save();
 
       canvas.translate(pos.x, pos.y);
       canvas.scale(baseScaleX * scale, baseScaleY * scale);
 
-      canvas.drawImageRect(_img.image, _img.frame, _img.spriteSourceSize, paint);
+      canvas.drawImageRect(_textures[i].image, _textures[i].frame, _textures[i].spriteSourceSize, paint);
 
       canvas.restore();
     }
   }
 
   void move(double dx, double dy) {
     for (int i  = 0; i < _numStars; i++) {
       double xPos = _starPositions[i].x;
       double yPos = _starPositions[i].y;
       double scale = _starScales[i];
@@ skipping 49 matching lines @@
   double dy = a.y - b.y;
   if (dx < 0.0) dx = -dx;
   if (dy < 0.0) dy = -dy;
   if (dx > dy) {
     return dx + dy/2.0;
   }
   else {
     return dy + dx/2.0;
   }
 }