Adds basic sprite sheet support to sprites

sky/examples/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;
 
 const double _shipRadius = 30.0;
 const double _lrgAsteroidRadius = 40.0;
 const double _medAsteroidRadius = 20.0;
 const double _smlAsteroidRadius = 10.0;
 const double _maxAsteroidSpeed = 1.0;
 
 const int _lifeTimeLaser = 50;
 
 const int _numStarsInStarField = 150;
 
 class GameDemoWorld extends NodeWithSize {
 
   // Images
-  Image _imgBg;
-  Image _imgAsteroid;
-  Image _imgShip;
-  Image _imgLaser;
-  Image _imgStar;
   Image _imgNebula;
 
+  SpriteSheet _spriteSheet;
+
   // Inputs
   double _joystickX = 0.0;
   double _joystickY = 0.0;
   bool _fire;
 
   Node _gameLayer;
 
   Ship _ship;
   List<Asteroid> _asteroids = [];
   List<Laser> _lasers = [];
   StarField _starField;
   Nebula _nebula;
   
-  GameDemoWorld(ImageMap images) : super(new Size(_gameSizeWidth, _gameSizeHeight)) {
+  GameDemoWorld(ImageMap images, this._spriteSheet) : super(new Size(_gameSizeWidth, _gameSizeHeight)) {
 
     // Fetch images
-    _imgBg = images["https://raw.githubusercontent.com/slembcke/GalacticGuardian.spritebuilder/GDC/Packages/SpriteBuilder%20Resources.sbpack/resources-auto/BurnTexture.png"];
-    _imgAsteroid = images["https://raw.githubusercontent.com/slembcke/GalacticGuardian.spritebuilder/GDC/Packages/SpriteBuilder%20Resources.sbpack/Sprites/resources-auto/asteroid_big_002.png"];
-    _imgShip = images["https://raw.githubusercontent.com/slembcke/GalacticGuardian.spritebuilder/GDC/Packages/SpriteBuilder%20Resources.sbpack/Sprites/resources-auto/GG_blueship_Lv3.png"];
-    _imgLaser = images["https://raw.githubusercontent.com/slembcke/GalacticGuardian.spritebuilder/GDC/Packages/SpriteBuilder%20Resources.sbpack/Sprites/resources-auto/laserBlue.png"];
-    _imgStar = images["https://raw.githubusercontent.com/slembcke/GalacticGuardian.spritebuilder/GDC/Packages/SpriteBuilder%20Resources.sbpack/Sprites/resources-auto/laserFlashPurple.png"];
-    _imgNebula = images["https://raw.githubusercontent.com/slembcke/GalacticGuardian.spritebuilder/GDC/Source/Resources/NebulaClouds.png"];
+    _imgNebula = images["res/nebula.png"];
 
     _gameLayer = new Node();
     this.addChild(_gameLayer);
 
     // Add some asteroids to the game world
     for (int i = 0; i < 5; i++) {
       addAsteroid(AsteroidSize.large);
     }
     for (int i = 0; i < 5; i++) {
       addAsteroid(AsteroidSize.medium);
     }
 
     // Add ship
     addShip();
 
     // Add starfield
-    _starField = new StarField.withImage(_imgStar, _numStarsInStarField);
+    _starField = new StarField(_spriteSheet["star.png"], _numStarsInStarField);
     _starField.zPosition = -2.0;
     addChild(_starField);
 
     // Add nebula
     addNebula();
 
     userInteractionEnabled = true;
     handleMultiplePointers = true;
   }
 
   // Methods for adding game objects
-
-  void addBackground() {
-    Sprite sprtBg = new Sprite(_imgBg);
-    sprtBg.size = new Size(_gameSizeWidth, _gameSizeHeight);
-    sprtBg.pivot = Point.origin;
-    _gameLayer.addChild(sprtBg);
-  }
   
   void addAsteroid(AsteroidSize size, [Point pos]) {
-    Asteroid asteroid = new Asteroid.withImage(_imgAsteroid, size);
+    Asteroid asteroid = new Asteroid(_spriteSheet["asteroid_big_1.png"], size);
     asteroid.zPosition = 1.0;
     if (pos != null) asteroid.position = pos;
     _gameLayer.addChild(asteroid);
     _asteroids.add(asteroid);
   }
 
   void addShip() {
-    Ship ship = new Ship.withImage(_imgShip);
+    Ship ship = new Ship(_spriteSheet["ship.png"]);
     ship.zPosition = 10.0;
     _gameLayer.addChild(ship);
     _ship = ship;
   }
 
   void addLaser() {
-    Laser laser = new Laser.withImage(_imgLaser, _ship);
+    Laser laser = new Laser(_spriteSheet["laser.png"], _ship);
     laser.zPosition = 8.0;
     _lasers.add(laser);
     _gameLayer.addChild(laser);
   }
 
   void addNebula() {
     _nebula = new Nebula.withImage(_imgNebula);
     _gameLayer.addChild(_nebula);
   }
   
@@ skipping 172 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.withImage(Image img, AsteroidSize this._asteroidSize) : super(img) {
+  Asteroid(Texture img, AsteroidSize this._asteroidSize) : super(img) {
     size = new Size(radius * 2.0, radius * 2.0);
     position = new Point(_gameSizeWidth * _rand.nextDouble(), _gameSizeHeight * _rand.nextDouble());
     rotation = 360.0 * _rand.nextDouble();
 
     _movementVector = new Point(_rand.nextDouble() * _maxAsteroidSpeed * 2 - _maxAsteroidSpeed,
                                 _rand.nextDouble() * _maxAsteroidSpeed * 2 - _maxAsteroidSpeed);
 
     userInteractionEnabled = true;
   }
 
   bool handleEvent(SpriteBoxEvent event) {
     if (event.type == "pointerdown") {
       colorOverlay = new Color(0x99ff0000);
     }
     else if (event.type == "pointerup") {
       colorOverlay = null;
     }
     return false;
   }
 }
 
 class Ship extends Sprite {
   Vector2 _movementVector;
   double _rotationTarget;
 
-  Ship.withImage(Image img) : super(img) {
+  Ship(Texture img) : super(img) {
     _movementVector = new Vector2.zero();
     rotation = _rotationTarget = 270.0;
 
     // Create sprite
     size = new Size(_shipRadius * 2.0, _shipRadius * 2.0);
     position = new Point(_gameSizeWidth/2.0, _gameSizeHeight/2.0);
   }
 
   void thrust(double x, double y) {
     _rotationTarget = convertRadians2Degrees(Math.atan2(y, x));
     Vector2 directionVector = new Vector2(x, y).normalize();
     _movementVector.addScaled(directionVector, 1.0);
   }
 
   void move() {
     position = new Point(position.x + _movementVector[0], position.y + _movementVector[1]);
     _movementVector.scale(0.9);
 
     rotation = dampenRotation(rotation, _rotationTarget, 0.1);
   }
 }
 
 class Laser extends Sprite {
   int _frameCount = 0;
   Point _movementVector;
   double radius = 10.0;
 
-  Laser.withImage(Image img, Ship ship) : super(img) {
+  Laser(Texture img, Ship ship) : super(img) {
     size = new Size(20.0, 20.0);
     position = ship.position;
     rotation = ship.rotation + 90.0;
     transferMode = TransferMode.plus;
     double rotRadians = convertDegrees2Radians(rotation);
     _movementVector = pointMult(new Point(Math.sin(rotRadians), -Math.cos(rotRadians)), 10.0);
     _movementVector = new Point(_movementVector.x + ship._movementVector[0], _movementVector.y + ship._movementVector[1]);
   }
 
   void move() {
     position = pointAdd(position, _movementVector);
     _frameCount++;
   }
 }
 
 // Background starfield
 
 class StarField extends Node {
-  Image _img;
+  Texture _img;
   int _numStars;
   List<Point> _starPositions;
   List<double> _starScales;
   List<double> _opacity;
 
-  StarField.withImage(Image this._img, int this._numStars) {
+  StarField(this._img, this._numStars) {
     _starPositions = [];
     _starScales = [];
     _opacity = [];
 
     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);
     }
   }
 
   void paint(PictureRecorder canvas) {
     // Setup paint object for opacity and transfer mode
     Paint paint = new Paint();
     paint.setTransferMode(TransferMode.plus);
 
-    double baseScaleX = 32.0/_img.width;
-    double baseScaleY = 32.0/_img.height;
+    double baseScaleX = 32.0/_img.size.width;

[eseidel, 2015/06/23 23:22:31]

I thought our style was to have spaces around operators?  I understand you're
not changing that part of this line, but if it is, we should probably fix it.

+    double baseScaleY = 32.0/_img.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.drawImage(_img, 0.0, 0.0, paint);
+      canvas.drawImageRect(_img.image, _img.frame, _img.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];
 
       xPos += dx * scale;
       yPos += dy * scale;
 
       if (xPos >= _gameSizeWidth) xPos -= _gameSizeWidth;
       if (xPos < 0) xPos += _gameSizeWidth;
       if (yPos >= _gameSizeHeight) yPos -= _gameSizeHeight;
       if (yPos < 0) yPos += _gameSizeHeight;
 
       _starPositions[i] = new Point(xPos, yPos);
     }
   }
 }
 
 class Nebula extends Node {
 
   Nebula.withImage(Image img) {
     for (int i = 0; i < 2; i++) {
       for (int j = 0; j < 2; j++) {
-        Sprite sprt = new Sprite(img);
+        Sprite sprt = new Sprite.fromImage(img);
         sprt.pivot = Point.origin;
         sprt.position = new Point(i * _gameSizeWidth - _gameSizeWidth, j * _gameSizeHeight - _gameSizeHeight);
         addChild(sprt);
       }
     }
   }
 }
 
 // Convenience methods
 
@@ skipping 19 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;
   }
 }