AnimationController.h

#pragma once

#include "Animation.h"
#include <map>


enum class TransitionCondition {
	None,

	SpeedAboveWalk,
	SpeedAboveRun,
	SpeedBelowRun,
	SpeedBelowWalk,

	EngageEnemy,
	AlertSignal,

	HealthDepleted,
	AnimationComplete
};
struct AnimationState {
	std::string animationName;
	float animationSpeed;
};
struct AnimationTransition {
	std::string fromState;
	std::string toState;
	float blendTime;
	TransitionCondition condition;
};

class AnimationController {
public:
	AnimationInstance instance;
	AnimationState* currentState = nullptr;
	std::map<std::string, AnimationState> states;
	std::map<std::string, float> parameters;
	std::map<std::string, bool> triggers;
	std::vector<AnimationTransition> transitions;

	void init(Animation* animaiton, int fromZYX) {
		instance.init(animaiton, fromZYX);
	}
	void addState(const std::string& name, float speed) {
		AnimationState s;
		s.animationName = name;
		s.animationSpeed = speed;
		states[name] = s;
	}
	void setState(const std::string& name) {
		if (currentState && currentState->animationName == name) {
			return;
		}
		currentState = &states[name];
	}
	void forceState(const std::string& name) {
		if (states.find(name) == states.end()) return;
		currentState = &states[name];
		instance.t = 0;
	}
	void update(float dt) {
		if (!currentState) return;

		if (checkCondition(TransitionCondition::HealthDepleted) && currentState->animationName != "death") {
			forceState("death");
		}

		for (auto& t : transitions) {
			if (t.fromState == currentState->animationName && checkCondition(t.condition)) {
				setState(t.toState);
				break;
			}
		}
		instance.update(currentState->animationName, dt*currentState->animationSpeed);
	}
	Matrix* getMatricies() {
		return instance.matrices;
	}
	void setParameter(const std::string& param, float value) {
		parameters[param] = value;
	}
	float getParameter(std::string name) {
		return parameters[name];
	}
	void setTrigger(const std::string& name) {
		triggers[name] = true;
	}
	bool getTrigger(const std::string& name) {
		if (triggers.find(name) != triggers.end() && triggers[name]) {
			triggers[name] = false;
			return true;
		}
		return false;
	}
	bool checkCondition(TransitionCondition condition) {
		switch (condition) {
		case TransitionCondition::SpeedAboveWalk:
			return getParameter("speed") > 3.0f;
		case TransitionCondition::SpeedBelowWalk:
			return getParameter("speed") < 3.0f;
		case TransitionCondition::SpeedAboveRun:
			return getParameter("speed") > 7.0f;
		case TransitionCondition::SpeedBelowRun:
			return getParameter("speed") < 7.0f;
		case TransitionCondition::HealthDepleted:
			return getParameter("health") <= 0.0f;
		case TransitionCondition::EngageEnemy:
			return getTrigger("attack");
		case TransitionCondition::AlertSignal:
			return getTrigger("roar");
		case TransitionCondition::AnimationComplete:
			return instance.animationFinished();
		}
		return false;
	}
	void addTransition(const std::string& from, const std::string& to, float blendTime, TransitionCondition condition)
	{
		AnimationTransition t;
		t.fromState = from;
		t.toState = to;
		t.blendTime = blendTime;
		t.condition = condition;
		transitions.push_back(t);
	}
};