Merge pull request #851 from vlidholt/master

Fixes issues in sprite constraints

examples/game/lib/explosions.dart

+part of game;
+
+class Explosion extends Node {
+  Explosion(SpriteSheet sheet) {
+    // Add particles
+    ParticleSystem particlesDebris = new ParticleSystem(
+      sheet["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
+    );
+    particlesDebris.zPosition = 1010.0;
+    addChild(particlesDebris);
+
+    ParticleSystem particlesFire = new ParticleSystem(
+      sheet["fire_particle.png"],
+      colorSequence: new ColorSequence([new Color(0xffffff33), new Color(0xffff3333), new Color(0x00ff3333)], [0.0, 0.5, 1.0]),
+      numParticlesToEmit: 25,
+      emissionRate: 1000.0,
+      startSize: 0.5,
+      startSizeVar: 0.1,
+      endSize: 0.5,
+      endSizeVar: 0.1,
+      posVar: new Point(10.0, 10.0),
+      speed: 10.0,
+      speedVar: 5.0
+    );
+    particlesFire.zPosition = 1011.0;
+    addChild(particlesFire);
+
+    // Add ring
+    Sprite sprtRing = new Sprite(sheet["explosion_ring.png"]);
+    sprtRing.transferMode = sky.TransferMode.plus;
+    addChild(sprtRing);
+
+    Action scale = new ActionTween( (a) => sprtRing.scale = a, 0.2, 1.0, 1.5);
+    Action scaleAndRemove = new ActionSequence([scale, new ActionRemoveNode(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(sheet["explosion_flare.png"]);
+      sprtFlare.pivot = new Point(0.3, 1.0);
+      sprtFlare.scaleX = 0.3;
+      sprtFlare.transferMode = sky.TransferMode.plus;
+      sprtFlare.rotation = randomDouble() * 360.0;
+      addChild(sprtFlare);
+
+      double multiplier = randomDouble() * 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 ActionRemoveNode(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);
+    }
+  }
+}

examples/game/lib/flash.dart

+part of game;
+
+class Flash extends NodeWithSize {
+  Flash(Size size, this.duration) : super(size) {
+    ActionTween fade = new ActionTween((a) => _opacity = a, 1.0, 0.0, duration);
+    ActionSequence seq = new ActionSequence([fade, new ActionRemoveNode(this)]);
+    actions.run(seq);
+  }
+
+  double duration;
+  double _opacity = 1.0;
+  Paint _cachedPaint = new Paint();
+
+  void paint(PaintingCanvas canvas) {
+    // Update the color
+    _cachedPaint.color = new Color.fromARGB((255.0 * _opacity).toInt(),
+                                            255, 255, 255);
+    // Fill the area
+    applyTransformForPivot(canvas);
+    canvas.drawRect(new Rect.fromLTRB(0.0, 0.0, size.width, size.height),
+      _cachedPaint);
+  }
+}

examples/game/lib/game_demo.dart

@@ -8,4 +8,9 @@ import 'package:sky/rendering/object.dart';
 import 'package:sky/widgets/framework.dart';
 import 'package:skysprites/skysprites.dart';
 
+part 'explosions.dart';
+part 'flash.dart';
 part 'game_demo_node.dart';
+part 'game_objects.dart';
+part 'repeated_image.dart';
+part 'star_field.dart';

examples/game/lib/game_objects.dart

+part of game;
+
+abstract class GameObject extends Node {
+  double radius = 0.0;
+  double removeLimit = 1280.0;
+  bool canDamageShip = true;
+  bool canBeDamaged = true;
+  double maxDamage = 3.0;
+  double damage = 0.0;
+
+  Paint _paintDebug = new Paint()
+    ..color=new Color(0xffff0000)
+    ..strokeWidth = 1.0
+    ..setStyle(sky.PaintingStyle.stroke);
+
+  bool collidingWith(GameObject obj) {
+    return (GameMath.pointQuickDist(position, obj.position)
+      < radius + obj.radius);
+  }
+
+  void move() {
+  }
+
+  void removeIfOffscreen(double scroll) {
+    ;
+    if (-position.y > scroll + removeLimit ||
+        -position.y < scroll - 50.0) {
+      removeFromParent();
+    }
+  }
+
+  void destroy() {
+    if (parent != null) {
+      Explosion explo = createExplosion();
+      if (explo != null) {
+        explo.position = position;
+        parent.addChild(explo);
+      }
+
+      removeFromParent();
+    }
+  }
+
+  int addDamage(double d) {
+    if (!canBeDamaged) return 0;
+
+    damage += d;
+    if (damage >= maxDamage) {
+      destroy();
+      return (maxDamage * 10).ceil();
+    }
+    return 10;
+  }
+
+  Explosion createExplosion() {
+    return null;
+  }
+
+  void paint(PaintingCanvas canvas) {
+    if (_drawDebug) {
+      canvas.drawCircle(Point.origin, radius, _paintDebug);
+    }
+    super.paint(canvas);
+  }
+
+  void setupActions() {
+  }
+}
+
+class Ship extends GameObject {
+  Ship(GameObjectFactory f) {
+    // Add main ship sprite
+    _sprt = new Sprite(f.sheet["ship.png"]);
+    _sprt.scale = 0.3;
+    _sprt.rotation = -90.0;
+    addChild(_sprt);
+    radius = 20.0;
+
+    canBeDamaged = false;
+    canDamageShip = false;
+
+    // Set start position
+    position = new Point(0.0, 50.0);
+  }
+
+  Sprite _sprt;
+
+  void applyThrust(Point joystickValue, double scroll) {
+    Point oldPos = position;
+    Point target = new Point(joystickValue.x * 160.0, joystickValue.y * 220.0 - 250.0 - scroll);
+    double filterFactor = 0.2;
+
+    position = new Point(
+      GameMath.filter(oldPos.x, target.x, filterFactor),
+      GameMath.filter(oldPos.y, target.y, filterFactor));
+  }
+}
+
+class Laser extends GameObject {
+  double impact = 1.0;
+
+  Laser(GameObjectFactory f) {
+    // Add sprite
+    _sprt = new Sprite(f.sheet["laser.png"]);
+    _sprt.scale = 0.3;
+    _sprt.transferMode = sky.TransferMode.plus;
+    addChild(_sprt);
+    radius = 10.0;
+    removeLimit = 640.0;
+
+    canDamageShip = false;
+    canBeDamaged = false;
+  }
+
+  Sprite _sprt;
+
+  void move() {
+    position += new Offset(0.0, -10.0);
+  }
+}
+
+abstract class Obstacle extends GameObject {
+
+  Obstacle(this._f);
+
+  double explosionScale = 1.0;
+  GameObjectFactory _f;
+
+  Explosion createExplosion() {
+    SoundEffectPlayer.sharedInstance().play(_f.sounds["explosion"]);
+    Explosion explo = new Explosion(_f.sheet);
+    explo.scale = explosionScale;
+    return explo;
+  }
+}
+
+abstract class Asteroid extends Obstacle {
+  Asteroid(GameObjectFactory f) : super(f);
+
+  Sprite _sprt;
+
+  void setupActions() {
+    // Rotate obstacle
+    int direction = 1;
+    if (randomBool()) direction = -1;
+    ActionTween rotate = new ActionTween(
+      (a) => _sprt.rotation = a,
+      0.0, 360.0 * direction, 5.0 + 5.0 * randomDouble());
+    _sprt.actions.run(new ActionRepeatForever(rotate));
+  }
+
+  set damage(double d) {
+    super.damage = d;
+    int alpha = ((200.0 * d) ~/ maxDamage).clamp(0, 200);
+    _sprt.colorOverlay = new Color.fromARGB(alpha, 255, 3, 86);
+  }
+}
+
+class AsteroidBig extends Asteroid {
+  AsteroidBig(GameObjectFactory f) : super(f) {
+    _sprt = new Sprite(f.sheet["asteroid_big_${randomInt(3)}.png"]);
+    _sprt.scale = 0.3;
+    radius = 25.0;
+    maxDamage = 5.0;
+    addChild(_sprt);
+  }
+}
+
+class AsteroidSmall extends Asteroid {
+  AsteroidSmall(GameObjectFactory f) : super(f) {
+    _sprt = new Sprite(f.sheet["asteroid_small_${randomInt(3)}.png"]);
+    _sprt.scale = 0.3;
+    radius = 12.0;
+    maxDamage = 3.0;
+    addChild(_sprt);
+  }
+}
+
+class MovingEnemy extends Obstacle {
+  MovingEnemy(GameObjectFactory f) : super(f) {
+    _sprt = new Sprite(f.sheet["ship.png"]);
+    _sprt.scale = 0.2;
+    radius = 12.0;
+    maxDamage = 2.0;
+    addChild(_sprt);
+
+    constraints = [new ConstraintRotationToMovement(dampening: 0.5)];
+  }
+
+  final double _swirlSpacing = 80.0;
+
+  _addRandomSquare(List<Offset> offsets, double x, double y) {
+    double xMove = (randomBool()) ? _swirlSpacing : -_swirlSpacing;
+    double yMove = (randomBool()) ? _swirlSpacing : -_swirlSpacing;
+
+    if (randomBool()) {
+      offsets.addAll([
+        new Offset(x, y),
+        new Offset(xMove + x, y),
+        new Offset(xMove + x, yMove + y),
+        new Offset(x, yMove + y),
+        new Offset(x, y)
+      ]);
+    } else {
+      offsets.addAll([
+        new Offset(x, y),
+        new Offset(x, y + yMove),
+        new Offset(xMove + x, yMove + y),
+        new Offset(xMove + x, y),
+        new Offset(x, y)
+      ]);
+    }
+  }
+
+  void setupActions() {
+
+    List<Offset> offsets = [];
+    _addRandomSquare(offsets, -_swirlSpacing, 0.0);
+    _addRandomSquare(offsets, _swirlSpacing, 0.0);
+    offsets.add(new Offset(-_swirlSpacing, 0.0));
+
+    List<Point> points = [];
+    for (Offset offset in offsets) {
+      points.add(position + offset);
+    }
+
+    ActionSpline spline = new ActionSpline((a) => position = a, points, 6.0);
+    spline.tension = 0.7;
+    actions.run(new ActionRepeatForever(spline));
+  }
+
+  Sprite _sprt;
+}

examples/game/lib/repeated_image.dart

+part of game;
+
+class RepeatedImage extends Node {
+  Sprite _sprt0;
+  Sprite _sprt1;
+
+  RepeatedImage(sky.Image image, [sky.TransferMode mode = null]) {
+    _sprt0 = new Sprite.fromImage(image);
+    _sprt0.size = new Size(1024.0, 1024.0);
+    _sprt0.pivot = Point.origin;
+    _sprt1 = new Sprite.fromImage(image);
+    _sprt1.size = new Size(1024.0, 1024.0);
+    _sprt1.pivot = Point.origin;
+    _sprt1.position = new Point(0.0, -1024.0);
+
+    if (mode != null) {
+      _sprt0.transferMode = mode;
+      _sprt1.transferMode = mode;
+    }
+
+    addChild(_sprt0);
+    addChild(_sprt1);
+  }
+
+  void move(double dy) {
+    double yPos = (position.y + dy) % 1024.0;
+    position = new Point(0.0, yPos);
+  }
+}

examples/game/lib/star_field.dart

+part of game;
+
+class StarField extends NodeWithSize {
+  sky.Image _image;
+  SpriteSheet _spriteSheet;
+  int _numStars;
+  bool _autoScroll;
+
+  List<Point> _starPositions;
+  List<double> _starScales;
+  List<Rect> _rects;
+  List<Color> _colors;
+
+  final double _padding = 50.0;
+  Size _paddedSize = Size.zero;
+
+  Paint _paint = new Paint()
+    ..setFilterQuality(sky.FilterQuality.low)
+    ..isAntiAlias = false
+    ..setTransferMode(sky.TransferMode.plus);
+
+  StarField(this._spriteSheet, this._numStars, [this._autoScroll = false]) : super(Size.zero) {
+    _image = _spriteSheet.image;
+  }
+
+  void addStars() {
+    _starPositions = [];
+    _starScales = [];
+    _colors = [];
+    _rects = [];
+
+    size = spriteBox.visibleArea.size;
+    _paddedSize = new Size(size.width + _padding * 2.0,
+                           size.height + _padding * 2.0);
+
+    for (int i  = 0; i < _numStars; i++) {
+      _starPositions.add(new Point(randomDouble() * _paddedSize.width,
+                                   randomDouble() * _paddedSize.height));
+      _starScales.add(randomDouble() * 0.4);
+      _colors.add(new Color.fromARGB((255.0 * (randomDouble() * 0.5 + 0.5)).toInt(), 255, 255, 255));
+      _rects.add(_spriteSheet["star_${randomInt(2)}.png"].frame);
+    }
+  }
+
+  void spriteBoxPerformedLayout() {
+    addStars();
+  }
+
+  void paint(PaintingCanvas canvas) {
+    // Create a transform for each star
+    List<sky.RSTransform> transforms = [];
+    for (int i = 0; i < _numStars; i++) {
+      sky.RSTransform transform = new sky.RSTransform(
+        _starScales[i],
+        0.0,
+        _starPositions[i].x - _padding,
+        _starPositions[i].y - _padding);
+
+      transforms.add(transform);
+    }
+
+    // Draw the stars
+    canvas.drawAtlas(_image, transforms, _rects, _colors, sky.TransferMode.modulate, null, _paint);
+  }
+
+  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 >= _paddedSize.width) xPos -= _paddedSize.width;
+      if (xPos < 0) xPos += _paddedSize.width;
+      if (yPos >= _paddedSize.height) yPos -= _paddedSize.height;
+      if (yPos < 0) yPos += _paddedSize.height;
+
+      _starPositions[i] = new Point(xPos, yPos);
+    }
+  }
+
+  void update(double dt) {
+    if (_autoScroll) {
+      move(0.0, dt * 100.0);
+    }
+  }
+}

packages/flutter_sprites/lib/constraint.dart

@@ -19,8 +19,8 @@ double _dampenRotation(double src, double dst, double dampening) {
   return src + delta;
 }
 
-class ConstraintRotationToMovement {
-  ConstraintRotationToMovement([this.baseRotation = 0.0, this.dampening]);
+class ConstraintRotationToMovement extends Constraint {
+  ConstraintRotationToMovement({this.baseRotation: 0.0, this.dampening});
 
   final double dampening;
   final double baseRotation;
@@ -43,8 +43,8 @@ class ConstraintRotationToMovement {
   }
 }
 
-class ConstraintRotationToNode {
-  ConstraintRotationToNode(this.targetNode, [this.baseRotation, this.dampening]);
+class ConstraintRotationToNode extends Constraint {
+  ConstraintRotationToNode(this.targetNode, {this.baseRotation: 0.0, this.dampening});
 
   final Node targetNode;
   final double baseRotation;