// тип анимации
class Direction {
  public:
    static const int TYPE_OUT = 0;
    static const int TYPE_IN = 1;

    static bool isTypeIn(int value) {
      return value == Direction::TYPE_IN;
    }

    static bool isTypeOut(int value) {
      return value == Direction::TYPE_OUT;
    }
};

// логика анимации 
void revealCircular(
  int x, int y,  // координаты центар
  int r,         // радиус заливки круга
  int direction, // 0 - расширение, 1 - сужение
  uint16_t color
) {
  if (Direction::isTypeOut(direction)) {
    for (int i = 0; i < r; ++i) {
      drawCircle(x, y, i, color);
    }
  } else if (Direction::isTypeIn(direction)) {
    for (int i = r; i > 0; --i) {
      drawCircle(x, y, i, color);
    }
  }
}

// вывод на матрицу круга
void drawCircle(
  int x, int y,
  int r,
  uint16_t color
) {
  matrix->drawCircle(x, y, r, color);
  matrix->swapBuffers(true);
}

class Interpolator {
  
  public:
    static const int TYPE_CONSTANT = 1;
    static const int TYPE_LINEAR = 2;
    static const int TYPE_ACCELERATE = 3;
    static const int TYPE_BOUNCE = 4;

  public:  
    int type = Interpolator::TYPE_CONSTANT;
    
    virtual int calculateX(double time) { return 1; }
    virtual int calculateY(double time) { return 1; }

};

class LinearInterpolator : public Interpolator {
  public: 
    int type = Interpolator::TYPE_LINEAR;

    virtual int calculateX(double time) { return time; }
};

class AccelerateInterpolator : public Interpolator {
  public:
    int type = Interpolator::TYPE_ACCELERATE;

    virtual int calculateX(double time) { 
      return (int) pow(time, 2 * 0.8); 
    }
};

class BounceInterpolator : public Interpolator {
  public:
    int type = Interpolator::TYPE_BOUNCE;

    virtual int calculateX(double time) {
      double result = 0;
      if (time < 0.31489) {
        result = 8 * pow(1.1226 * time, 2);
      } else if (0.31489 <= time && time < 0.65990) {
        result = 8 * pow(1.1226 * time - 0.54719, 2) + 0.7;
      } else if (0.65990 <= time && time < 0.85908) {
        result = 8 * pow(1.1226 * time - 0.85260, 2) + 0.9;
      } else if (0.85908 <= time) {
        result = 8 * pow(1.1226 * time - 1.04350, 2) + 0.95;
      }
      return (int) result;
    }
};

class MovableSprite {
  public: 
    MovableSprite(
      int x, 
      int y, 
      int size, 
      uint16_t color
    ) {
      _x = x;
      _y = y;
      _size = size;
      _color = color;
      _renderParams = new RenderParams();
    };

    int x() { return _x; }
    int y() { return _y; }
    int size() { return _size; }
    uint16_t color() { return _color; }

    void setX(int x) { _x = x; }
    void setY(int y) { _y = y; }
    void setColor(uint16_t color) { _color = color; }

    RenderParams* getRenderParams() {
      return _renderParams;
    }
    
    String toString() {
      return String(x()) + "," + String(y()) + "," + String(size()) + "," + String(color());
    }

    void move(int dx, int dy) {
        _x += dx;
        _y += dy;
    }

    private:
      int _x, _y;
      int _size;
      uint16_t _color;
      RenderParams *_renderParams;
}

List<MovableSprite*> sprites = List<MovableSprite*>();
MovableSprite *sprite1 = new MovableSprite(5, 5, 2, 99);
MovableSprite *sprite2 = new MovableSprite(5, 10, 2, 89);
MovableSprite *sprite3 = new MovableSprite(5, 15, 2, 79);
MovableSprite *sprite4 = new MovableSprite(5, 20, 2, 69);

List<Interpolator> interpolators = List<Interpolator>()

void loop() {
  if (isRequireGreeting) {
    displayGreeting();
    isRequireGreeting = false;
  } else {
    displayMovables();
    changeRanderParams();
  }
}

...

void changeRanderParams() {
  for (int i = 0; i < sprites.getSize(); ++i) {
    RenderParams *render = sprites[i]->getRenderParams();
    render->changeTime();
  }
}

void displayMovables() {
  draw();
  moving();
}

void moving() {
  for (int i = 0; i < sprites.getSize(); ++i) {
    MovableSprite *sprite = sprites[i];
    RenderParams *render = sprite->getRenderParams();

    if (isDebug) {
      Serial.println(
        "moving: " + String(i) + ", " 
        + String(render->getTime()) + ", "
        + String(sprite->x()) 
      );
    }

    if (sprite->x() >= 64) {
      if (render->getCycles() > 3) {
        render->resetCycles();
        render->resetTime();
        sprite->setX(0);
      } else {
        render->incrementCycles();
      }
      sprite->setX(sprite->x() - render->getCycles()*64);
    }
  
    double time = render->getTime();

    int x = Interpolator().calculateX(time);
   
    if (i == 1) {
      x = LinearInterpolator().calculateX(time);
    } else if (i == 2) {
      x = AccelerateInterpolator().calculateX(time);
    } else if (i == 3) {
      x = BounceInterpolator().calculateX(time);
    }

    if (i == 0) {
      sprite->move(x, 0);
    } else {
      sprite->setX(x);
    }
  }
}