class AnimationBinder
{
    public:
        virtual void bind() = 0;
        virtual void unbind() = 0;
        virtual int priority() = 0;

        bool operator < (AnimationBinder *other)
        {
            return priority() < other->priority();
        }

        bool activated;
        bool binded;
};

#include "AnimationBinder.h"

enum ANIMATION_STATE
{
     EAS_IDLE,
     EAS_RUNNING,
     EAS_SWIMING,
     ... etc
     EAS_JUMPING,
     EAS_COUNT
};

class AnimationManager
{
    public:
        AnimationManager(IAnimatedMeshSceneNode* NePlayer);
        void activate(int animNumber, bool value);
    private:
         std::vector<AnimationBinder*> anim;
};

#include "AnimationManager.h"

#include "GenericState.h"
#include "JumpState.h"

AnimationManager::AnimationManager(IAnimatedMeshSceneNode* NePlayer)
{
       anim.push_back(new GenericState(NePlayer,0,0,0,false)); // idle ?
       anim.push_back(new GenericState(NePlayer,1,0,80,true)); // running ?
       anim.push_back(new GenericState(NePlayer,2,80,160,true)); // swimming ?
       ... etc
       anim.push_back(new JumpState(NePlayer));
}
void AnimationManager::activate(int animNumber, bool value)
{
       auto current = anim[animNumber];
       current->activated = value;

       if(current->binded && !value)
           current->unbind();

       current = anim[0];

       for(int i = 0; i<anim.size(); ++i)
            if(current < anim[i] && anim[i]->activated)
               current = anim[i];

        if(current->activated && !current->binded)
               current->bind();
}

#include "AnimationBinder.h"

class GenericState : public AnimationBinder
{
    public:
        GenericState(IAnimatedMeshSceneNode* NePlayer,int AnimPriority, int FrameStart, int FrameEnd, bool Frameloop = false);

        virtual void bind();
        virtual void unbind();
        virtual int priority();

        IAnimatedMeshSceneNode* NodePlayer;
        int Apriority;
        int start;
        int end;
        bool loop;
};

GenericState::GenericState(IAnimatedMeshSceneNode* NePlayer,int AnimPriority, int FrameStart, int FrameEnd, bool Frameloop)
{
    NodePlayer = NePlayer;
    Apriority = AnimPriority;
    start = FrameStart;
    end = FrameEnd;
    loop = Frameloop;
}
void GenericState::bind()
{
   binded = true;
   NodePlayer->setAnimationSpeed(50);
   NodePlayer->setLoopMode(loop);
   NodePlayer->setFrameLoop(start,end);
}
void GenericState::unbind()
{
   binded = false;
   NodePlayer->setAnimationSpeed(50);
   NodePlayer->setLoopMode(false);
   NodePlayer->setFrameLoop(0,0);
}
int GenericState::priority()
{
    return Apriority;
}

#include "AnimationBinder.h"

class JumpState : public AnimationBinder, public irr::scene::IAnimationEndCallBack
{
    public:
        JumpState(AnimationManager* a, IAnimatedMeshSceneNode* NePlayer);

        virtual void bind();
        virtual void unbind();
        virtual int priority();

        virtual void OnAnimationEnd(IAnimatedMeshSceneNode *node);

        AnimationManager *amgr;
        IAnimatedMeshSceneNode* NodePlayer;
        int Apriority;
        int start;
        int end;
        int state;
        bool loop;
};

#include "JumpState.h"

JumpState::JumpState(AnimationManager* a, IAnimatedMeshSceneNode* NePlayer) : state(0), amgr(a)
{
    NodePlayer = NePlayer;
    NodePlayer = NePlayer;
    Apriority = AnimPriority;
    start = FrameStart;
    end = FrameEnd;
    loop = Frameloop;
}
void JumpState::bind()
{
   state = 0;
   NodePlayer->setAnimationEndCallback(this);
   binded = true;
   NodePlayer->setAnimationSpeed(50);
   NodePlayer->setLoopMode(false);
   NodePlayer->setFrameLoop(200,230);
}
void JumpState::unbind()
{
   binded = false;
   NodePlayer->setAnimationSpeed(50);
   NodePlayer->setLoopMode(false);
   NodePlayer->setFrameLoop(0,0);
   NodePlayer->setAnimationEndCallback(0);
}
int JumpState::priority()
{
    return Apriority;
}
void JumpState::OnAnimationEnd(IAnimatedMeshSceneNode *node)
{
      float d = distanceFromGround(node);
      if(d > 0.1f)
      {
          NodePlayer->setLoopMode(true);
          NodePlayer->setFrameLoop(230,270);
      }
      else
      {
          state++;

          if(state == 2)
              amgr->active(EAT_JUMP, false);

          NodePlayer->setLoopMode(false);
          NodePlayer->setFrameLoop(270,300);
      }
}

class Player : public irr::IEventReceiver
{
    public:
      Player()
      {
          loadMesh();
          node = smgr->addAnimatedMeshSceneNode(... blabla)
          anim = new AnimationManager(node);
      }
      ... blabla bla
      virtual bool OnEvent(const irr::SEvent &ev)
      {
          if(event.eventype == irr::quelquechose_JOYSTIC)
          {
              int keys = event.blabla.Sate;
              anim.active(EAS_RUNNING, keys & 0b000001 && onGround);
              anim.active(EAS_SWIMMING, keys & 0b000001 && onWater);
              ... etc
              anim.active(EAS_ATTACKING, keys & 0b001000);
          }
      }
    private:
      AnimationManager *anim;
}