/**
*******************************************************************************

  @file /gui/engine/UnitControllers.h
  @brief Kontrolery na ovladani jednotek a vojacku.

  Makro STEERING aktivuje pouziti steeringu v pohybu jednotek po mape.
  Makro DEBUG_STEERING aktivuje kresleni prekazek ve steeringu.

  @author Vajicek
  @version 0.1
 
******************************************************************************/
#ifndef UNITCONTROLLERS_H
#define UNITCONTROLLERS_H

//
#include <queue>

//
#include "common/mm.h"
#include "gui/engine/Controllers.h"

namespace gui{

//FWD
class TSceneScript;
class TUnit;
class TUnitMember;
class TguiMap;
class TQuadrant;


/** Prekazka v mape pro steering. 
*/
class TObstacle //##
{
public:
  P2F p2fPosition;  ///< Pozice prekazky.
  float fRadius;    ///< Polomer prekazky.
  /** Konstruktor.
    @param position Pozice.
    @param radius Polomer.
  */
  TObstacle(P2F *position, float radius);
  /** Spocita teziste.
    @param[out] position Poloha teziste.
  */
  void getCenterOfGravity(P2F *position);
  /// Kolize
  //@{
  int collision(TObstacle* o);
  int collision(P2F* a);
  int collision(float cx, float cy, float size);
  int collision(TQuadrant* q);
  //@}
};

//FWD
class TSteeringKernelController;


/** Implementace rozhodovaciho algoritmu.
*/
class TAgent: public TObstacle
{
public:
  P2F* pPreviousGoal;                     ///< predchozi cil
  P2F* pNextGoal;                         ///< pristi cil
  std::vector<P2F> vRoute;                ///< cesta, seznam cilu
  TSteeringKernelController* steeringmap; ///< prekazky  
  
  float fGoalSensor;  ///< vzdalenost na kterou je cil povazovane za dosazeny
  float fOutlook;     ///< vyhled, odvozuje se podle manevrovacich schopnosti agenta

  float fMass;
  float fMaxForce;          ///< maximalni sila, projevuje se ve schopnosti menit smer a rychlost
  float fMaxSpeed;          ///< maximalni rychlost
  float fMaxRotationSpeed;  ///< maximalni uhlova rychlost otoceni agenta

  P2F p2fVelocity;  ///< rychlost 
  P2F p2fDirection; ///< smer agenta 

  /** Vytvor agente se specifickymi vlastnostmi. 
      
    @param skc jadro steeringu
    @param radius polomer agenta
    @param mass hmotnost
    @param max_speed maximalni rychlost
    @param max_force maximalni sila
    @param max_rotation_speed maximalni rotacni rychlost   
  */
  TAgent( TSteeringKernelController* skc, float radius, float mass, 
          float max_speed, float max_force, float max_rotation_speed);

  /// Podminky.
  //@{
  void collisionAvoid(P2F *avoid_force);
  void seek(P2F *seek_force);
  void truncateVelocity(P2F* new_velocity);
  //@}
  
  /** Spocita steering.
    Modifikuje rychlost, pozici a smer, tak aby to odpovidalo 
    podminkam plynoucim z aktualniho stavu sveta a kratkemu 
    casovemu useku.
    
    @param sec casovy usek ve zlomku sekundy.
  */
  void steer(float sec);  
    
  /// Konstrukce cesty.
  //@{
  
  /** Prida dalsi cil.    
    @param goal souradnice dalsiho cile
  */
  void addGoal(P2F* goal);
  
  /** Prejde na dalsi cil.
    Pokud dalsi cil neexistuje, nastavi pNextGoal na NULL.
  */
  void nextGoal();
  
  /** Smaze cile.
    Smaze seznam cilu. Jako prvni ulozi aktualni pozici(kvuli mereni).
    pNextGoal nastavi na NULL.
  */
  void clearRoute();
  //@} 
};


/** Quadrantovy strom.
*/
class TQuadrant //##
{
public:
  P2F p2fCenter;  ///< stred kvadrantu
  float fSize;    ///< delka steny kvadrantu
  // vazby
  TQuadrant* Parent;        ///< rodic kvadrantu
  TQuadrant* Subquadrant[4];///< subquadrant nebo null pokud list 
  // data
  std::vector<TObstacle*> Obstacles;      ///< prekazky v subquadrantu
  //
  TQuadrant(TQuadrant* parent, int q);
  TQuadrant(float cx, float cy, float size);
  ~TQuadrant();
  //
  TQuadrant* addObstacle(TObstacle* o);
  TObstacle* delObstacle(TObstacle* o);
  // kolize
  int collision(float cx, float cy, float size);
  int collision(TObstacle* o);
  //
  static TQuadrant* buildQuadrantTree(std::vector<TObstacle*>* obstacles);
};


/** Mapa pro steering.
  Hlavni trida pro preprezentaci prostredi pro 
  steering agentu(panacku). Obsahuje mapu.
  Nemusi byt nutne kontroler.
*/
class TSteeringKernelController: public TController {
public:
  TQuadrant* Root;
  //
  void findNearestFreePosition(TObstacle* o);
  //
  void insertObstacle(TObstacle* o);
  void removeObstacle(TObstacle* o);
  void moveObstacle(TObstacle* o);
  void draw();
  //
  void buildStructures(TguiMap* map);
  TSteeringKernelController();
  ~TSteeringKernelController();
  //
  virtual void update(int absoluteTime);
};


/** Virtualni agent.
  Steering vdazeny do systemu kontrolleru.
*/
class TSteeringController: public TAgent, public TController {
protected:
  /// mapa pro steering
  TSteeringKernelController* stkctrl;
public:
  TSteeringController(TSteeringKernelController* cntrl, TUnitMember* um);
  
  /// precte pozici z polohy um ve 3d scene (a upravi pozici v mape prekazek)
  void refreshPosition();
  
  /// naplanuje cestu 
  void walk(int points_c, P2F* points, int startAt = -1);

  //lasttime
  //vypocet steeringu od posledniho
  virtual void update(int absoluteTime);

  /// pro ladici ucely
  void draw(TguiMap* map );
};















/** Pohybuje s jednotkou.
  Nema zadnou spec funkci.
*/
class TUnitController: public TController {
public:
  //
  void test();
  //
  virtual void update(int absoluteTime);
  /** Konstruktor.
    @param unit Jednotka, kterou planovac ovlada.
  */
  TUnitController(TUnit *unit);
};











/// Typ akce planovace TUnitMemberController
enum TUnitMemberControllerAction {
  umcaIdle,             ///<nic nedela
  umcaPlanWalk,         ///<vylepseny walk, planuje od aktualni pozice, moznost napojovat
  umcaWalk, 
  umcaAttack,           ///<boj
  umcaDistantAttack,    ///<strelba
  umcaFadeOut, 
  umcaFadeIn, 
  umcaScript,           ///<
  umcaDisapper,         ///<odstraneni ze sceny 
  umcaWait              ///<pauza mezi akcema
};

/// Seznam kontrolnich bodu cesty
struct TPathPointsBuff{
  int points_c;
  P2F points[1];
};

#define PATH_EQDEST       1
#define PATH_EQDEST_EQDIR 2

/** Ovlada pohyb jednotlivce po mape, a jine manipulace.
  
  -pohyb
    +algoritmus pohybu po obecnych krivkach
  -postupne mizeni a zviditelnovani
  -odstraneni z mapy
  -spousteni skriptu

*/
class TUnitMemberController: public TScheduler {
private:
  float pathSmoothness; ///< hladkos cesty
  /** Napoji cestu na existujici krivku.
    @param sa Akce kterou pohyb po teto ceste predstavuje.
    @param points_c Pocet ridicich bodu.
    @param points Ridici body.
  */
  void joinPath(TSheduledAction* sa, int points_c, P2F* points);
  /** Vytvori cestu.
    @param sa Akce kterou pohyb po teto ceste predstavuje.
    @param points_c Pocet ridicich bodu.
    @param points Ridici body.
  */
  void planPath(TSheduledAction* sa, int points_c, P2F* points);
  /** Vytvori trasu z aktualni pozice(=prida aktualni pozici na zacatek).
    @param sa Akce kterou pohyb po teto ceste predstavuje.
    @param points_c Pocet ridicich bodu.
    @param points Ridici body.
  */
  void planPathFromHere(TSheduledAction* sa, int points_c, P2F* points);
public:
  ///debug
  TGenericCurve* curpath;
  
  /// Instalatory akci, startAt = -1 akce se pripoji za posledni naplanovanou
  //@{
  /** Naplanuj cestu a uloz na konec fornty akci.
    @param points_c Pocet bodu a tecen.
    @param points Body.
    @param tangents Tecny v bodech.
    @param startAt Kdy zacit.
  */
  void planWalk     (int points_c, P2F* points, P2F* tangents, int startAt = -1);
  /** Naplanuj cestu.
    @param points_c Pocet bodu a tecen.
    @param points Body.
    @param startAt Kdy zacit.    
  */
  void walk         (int points_c, P2F* points, int startAt = -1);
  /** Fade-out efekt(zneviditelneni).
    @param delay  Doba.
    @param startAt Zacatek.
  */
  void fadeout      (int delay = 2000, int startAt = -1);
  /** Fade-in efekt(zviditelneni).
    @param delay  Doba.
    @param startAt Zacatek.
  */
  void fadein       (int delay = 2000, int startAt = -1);
  /** Naplanovnani scenare.
    @param c Scenar.
    @param startAt Cas.
  */
  void script       (TSceneScript* c, int startAt = -1);
  /** Odstraneni objektu.
    @param startAt Cas.
  */
  void disappear    (int startAt = -1);
  //@}
  
  /// predefinovane vytvoreni akce
  virtual TSheduledAction* createAction(int act, void* data, int start, int dur);
  /// predefinovane zruseni akce
  virtual void disposeAction(TSheduledAction* ac);
  /// update akce
  virtual int updateAction(int rtime, TSheduledAction* sa);
  /** Konstruktor.
    @param um Unit member.
  */  
  TUnitMemberController(TUnitMember* um);
};


}//namespace
#endif
/*****************************************************************************/