#ifndef ENTITY_H
#define ENTITY_H

/*
* file Entity.h
* Entity
* 
* 27/01/2006
* Copyright Piquier Production
* 
*/

#include "Point2D.h"
#include "RenderableEntity.h"
#include "CollisionInfo.h"

#include "MemoryManager/debugNew.h"

/**
* Classe Entity, modelise un objet actif sur la carte
*/

class Entity : public RenderSystem::RenderableEntity, public CollisionInfo
{
protected:

	/*
	* Position de l'entité sur la carte
	*/
	Point2D position;

	/**
	* Points de vie
	*/
	int healthPoint;

	/**
	* Orientation de l'entité en degré
	* utilisé par le moteur 3D pour l'affichage
	*/
	float orientation;

	/**
	* Vitesse de l'entité
	* à spécifié par les classes filles
	*/
	float speed;

	/**
	* Rayon de l'entité (en cases)
	* Utilisé pour atteindre un point (zone de portée de mouvement)
	*  et pour la zone de collision
	*/
	float radius;

public:

	/**
	* constructeur
	*/
	Entity(Point2D p);

	/**
	* constructeur
	*/
	Entity();
	
	/**
	* destructeur
	*/
	virtual ~Entity(void);

	/**
	* permet de diminuer les points de vies de l'entité
	*/
	virtual void Entity::decreaseHealthPoint(int decreasePoint) ;

	/**
	* accesseur en lecture à position
	*/
	virtual Point2D getPosition();

	/**
	* accesseur en écriture à position
	*/
	virtual void setPosition(Point2D p);
	
	/**
	* accesseur en lecture à healthPoint
	*/
	virtual int getHealthPoint();

	/**
	* accesseur en écriture à healthPoint
	*/
	virtual void setHealthPoint(int hp);

	/**
	* accesseur en lecture à orientation
	*/
	virtual float getOrientation();

	/**
	* accesseur en écriture à orientation
	*/
	virtual void setOrientation(float o);
	
	/**
	* accesseur en lecture à speed
	*/
	virtual float getSpeed();

	/**
	* accesseur en écriture à speed
	*/
	virtual void setSpeed(float s);

	/**
	 * methode retournant la position de l'entitée pour l'affichage
	 */
	virtual Point2D& getRenderableEntityPosition();

	/**
	 * methode servant à retourner l'angle dans laquelle regarde l'entitée
	 */
	virtual float getRenderableEntityAngle();

	/**
	 * methode permettant de recuperer le rayon de collision d'une entitée
	 * @return float : le rayon de collision de l'entité.
	 */
	virtual float getCollisionRadius();

	/**
	 * methode permettant de changer le rayon de collision d'une entitée
	 * @return void
	 */
	virtual void setCollisionRadius(float r);

	/**
	 * methode permettant de recuperer le rayon d'une entitée, exprimé en cases (unité de mesure de la carte)
	 * Le rayon d'une entité est une distance minimale dans laquelle l'entité considère qu'elle couvre tous
	 * les points de la zone
	 * @return float : le rayon de collision de l'entité.
	 */
	virtual float getRadius();
	
	/**
	 * methode permettant de recuperer le rayon d'une entitée, exprimé en cases (unité de mesure de la carte)
	 * Le rayon d'une entité est une distance minimale dans laquelle l'entité considère qu'elle couvre tous
	 * les points de la zone
	 * @return void
	 */
	virtual void setRadius(float r);

	/**
	 * methode permettant de recuperer la direction dans laquelle est tournée l'entité
	 * @return float : l'angle dans lequel regarde l'entité. (en degré)
	 */
	virtual float getDirectionAngle();

	/**
	 * methode appelée par le manager de collision pour definir 
	 * la nouvelle position de l'entité suite à une collision. (identique à setPosition)
	 * @param pos : la nouvelle position de l'entité.
	 */
	virtual void setPostCollisionPosition(Point2D& pos);

	/**
	 * methode permettant de connaitre la vitesse de l'entité afin de determiner des priorité dans les collisions.
	 *
	 * Le manager de collision donne une plus grande priorité aux unitée plus rapides lors d'une collision entre
	 * 2 entités en mouvement.
	 * @return float : la vitesse de deplacement de l'unitée.
	 */
	virtual float getSpeedForCollision();

	/**
	 * methode permettant de savoir si l'entité est en mouvement ou pas.
	 *
	 * lors d'une collision, une entité en mouvement est favorisée par rapport à une entité immobile.
	 * retourne false à tous les coups. doit-être redéfinie par les classes héritant et pouvant
	 * se déplacer (Unit)
	 * @return bool : true si l'entité est en mouvement, false sinon.
	 */
	virtual bool isMoving();

	/**
	 * methode permettant de savoir si l'entité est en vie ou pas.
	 *
	 * @return bool : true si l'entité est en vie, false sinon.
	 */
	virtual bool isAlive();

	/**
	 * methode appelée par le manager de collision pour signaler a une entité qu'elle a subit une collision.
	 *
	 * Ceci permet a l'entité de savoir si elle doit reagire pour revenir à sa position d'origine ou pas.
	 */
	virtual void signalCollision();

	/**
	 * Permet de savoir si l'entité affichable possède de la vie
	 * @return bool : true si l'entité a des point de vie, false sinon
	 */
	virtual bool haveLife();
	/**
	 * Permet d'obtenir la vie courante de l'entité
	 *
	 * @return la vie courante
	 */
	virtual float getCurrentLife();


};

#include "MemoryManager/debugNewOff.h"

#endif
