SDL_Surface *mapMaximImg(IMG_Load("test-data/maxim-map.png"));
                Sprite mapMaximSprite(mapMaximImg, 32, 64);
+               SimpleAnimation mapMaximAnimation(&mapMaximSprite, 128, 2, 0, 0, true);
                Entity mapMaxim;
-               mapMaxim.SetSprite(&mapMaximSprite);
+               mapMaxim.SetAnimation(&mapMaximAnimation);
                mapMaxim.Position() = Vector<float>(80, 128);
 
                InitScreen screen(width, height);
 
 namespace map {
 
 Entity::Entity()
-: sprite(0)
+: animation(0)
 , orientation(ORIENTATION_NORTH)
 , speed(0) {
 
 void Entity::SetOrientation(Orientation o) {
        orientation = o;
        UpdateVelocity();
-       animation.SetColOffset(orientation);
+       runner.SetColOffset(orientation);
 }
 
 void Entity::SetSpeed(float s) {
        UpdateVelocity();
 }
 
+void Entity::SetAnimation(const graphics::Animation *a) {
+       animation = a;
+       runner.ChangeAnimation(animation);
+}
+
+
 void Entity::UpdateVelocity() {
        if (speed == 0.0f) {
                velocity = Vector<float>();
 
 void Entity::Render(SDL_Surface *dest, const Vector<int> &offset) const {
        // TODO: configurable sprite offsets
-       if (animation.Running()) {
-               animation.DrawCenter(dest, offset + position);
+       if (runner.Running()) {
+               runner.DrawCenter(dest, offset + position);
        } else {
-               sprite->DrawCenter(dest, offset + position, orientation);
+               animation->GetSprite()->DrawCenter(dest, offset + position, orientation);
        }
 }
 
 
        geometry::Vector<float> &Velocity() { return velocity; }
        const geometry::Vector<float> &Velocity() const { return velocity; }
 
-       void SetSprite(const graphics::Sprite *s) { sprite = s; }
-       graphics::AnimationRunner &Animation() { return animation; }
-       const graphics::AnimationRunner &Animation() const { return animation; }
+       void SetAnimation(const graphics::Animation *a);
+       void StartAnimation(app::Application &ctrl) { runner.Start(ctrl); }
+       void StartAnimation(app::State &ctrl) { runner.Start(ctrl); }
+       void StopAnimation() { runner.Stop(); }
+       bool AnimationRunning() const { return runner.Running(); }
 
        void SetOrientation(Orientation);
        Orientation GetOrientation() const { return orientation; }
        void UpdateVelocity();
 
 private:
-       const graphics::Sprite *sprite;
-       graphics::AnimationRunner animation;
+       const graphics::Animation *animation;
+       graphics::AnimationRunner runner;
        geometry::Vector<float> position;
        geometry::Vector<float> velocity;
        Orientation orientation;
 
                        } else {
                                controlled->SetSpeed(0.0f);
                        }
+                       if (!controlled->AnimationRunning()) {
+                               controlled->StartAnimation(*this);
+                       }
                } else {
                        controlled->SetSpeed(0.0f);
+                       controlled->StopAnimation();
                }
                if (nowLock != lastLock) {
                        lastLock = nowLock;