je t'est déjà répondue pour un probleme similaire (même erreur de compilation)

a tu inclue le header (.h) de AnimationManager dans ton header de la class player ?
la définition de la class est obligatoire avans de pouvoire l'utilisé, et n'est jamais établie de manière globale
il te faut résoudre les dépendences directement ou indirectement suivant le contexte

non pour l'utiliser tu passe par AnimationManager
et il n'a pas besoin de (,int priority,int start, int end, bool loop = false)
l'idéal serait que tu les initializes depuis l'animation elle même

que ne comprend tu pas ici ?
tu fait des amalgames ?
que je résolve ça !

bon comme tu as l'aire d'avoire du mal, j'espère que ça t'aideras
perso j'organiserais comme ceci

AnimationBinder.hAnimationManager.hAnimationManager.cppGenericState.hGenericState.cppJumpState.hJumpState.cppPlayer.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#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;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#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();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#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;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#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;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

#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);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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;
}

faut pas trop ce prendre la tête
si tu peut faire un nouveaux fichier fait le (header/implementation)
si tu peut gagner en clarté de code fait le aussi
de sorte que la lecture soit "évidente" pour toi (c'est subjectif)