[Effen] fix typo in animation code (impluse => impulse)

sky/framework/animation/mechanics.dart

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 import 'dart:math' as math;
 
 const double kGravity = -0.980;
 
 abstract class System {
   void update(double deltaT);
 }
 
 class Particle extends System {
   final double mass;
   double velocity;
   double position;
 
   Particle({this.mass: 1.0, this.velocity: 0.0, this.position: 0.0});
 
-  void applyImpluse(double impluse) {
-    velocity += impluse / mass;
+  void applyImpulse(double impulse) {
+    velocity += impulse / mass;
   }
 
   void update(double deltaT) {
     position += velocity * deltaT;
   }
 
   double get energy => 0.5 * mass * velocity * velocity;
          set energy(double e) {
     assert(e >= 0.0);
     velocity = math.sqrt(2 * e / mass);
@@ skipping 39 matching lines @@
 class ParticleInBoxWithFriction extends ParticleInBox {
   final double friction;
   final double _sign;
 
   ParticleInBoxWithFriction({Particle particle, Box box, this.friction})
       : super(particle: particle, box: box),
         _sign = particle.velocity.sign;
 
   void update(double deltaT) {
     double force = -_sign * friction;
-    particle.applyImpluse(force * deltaT);
+    particle.applyImpulse(force * deltaT);
     if (particle.velocity.sign != _sign)
       particle.velocity = 0.0;
     super.update(deltaT);
   }
 }
 
 class Spring {
   final double k;
   double displacement;
 
   Spring(this.k, {this.displacement: 0.0});
 
   double get force => -k * displacement;
 }
 
 class ParticleAndSpringInBox extends System {
   final Particle particle;
   final Spring spring;
   final Box box;
 
   ParticleAndSpringInBox({this.particle, this.spring, this.box}) {
     _applyInvariants();
   }
 
   void update(double deltaT) {
-    particle.applyImpluse(spring.force * deltaT);
+    particle.applyImpulse(spring.force * deltaT);
     particle.update(deltaT);
     _applyInvariants();
   }
 
   void _applyInvariants() {
     box.confine(particle);
     spring.displacement = particle.position;
   }
 }
 
 class ParticleClimbingRamp extends System {
   final Particle particle;
   final Box box;
   final double slope;
 
   ParticleClimbingRamp({
       this.particle,
       this.box,
       this.slope,
       double targetPosition}) {
     double deltaPosition = targetPosition - particle.position;
     particle.energy = -kGravity * slope * deltaPosition * particle.mass;
     box.confine(particle);
   }
 
   void update(double deltaT) {
     particle.update(deltaT);
-    // Note that we apply the impluse from gravity after updating the particle's
+    // Note that we apply the impulse from gravity after updating the particle's
     // position so that we overestimate the distance traveled by the particle.
     // That ensures that we actually hit the edge of the box and don't wind up
     // reversing course.
-    particle.applyImpluse(kGravity * slope * deltaT);
+    particle.applyImpulse(kGravity * slope * deltaT);
     box.confine(particle);
   }
 }