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

  @file /gui/model/guiUnit.h
  @brief Reprezentace jednotky(vojacku)
  

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

#include "common/mm.h"
//
#include "gui/common/mymath.h"
//
#include "gui/model/ModelRep.h"
#include "gui/model/hexy.h"
//
#include "gui/engine/UnitControllers.h"
#include "gui/engine/AdvGeom.h"
#include "gui/engine/Effects.h"
#include "gui/model/selection.h"
#include "gui/model/UnitFormation.h"
#include "gui/engine/SceneScripts.h"

namespace gui{

/// velikost bufferu pro cestu
#define MAX_MARCH_LEN     20

//FWD
class TBuilding;
class TUnit;

/** GUI rozliseni typu utoku. 
  Rozlisni typu utoku je zvlast jeste v gui. Napr. kvuli spolecnym 
  skriptum. Mapuje se na typu utoku podle pravidel ulozeny v xml.
*/
enum TAttackType
{
  atDistantAttack,
    atArcherAttack, 
    atCatapultAttack, 
    atMagicMissileAttack, 
  atFaceToFace, 
    atBlastAttack,
  atNonCombat
};

/// Zjisti jestli jde o strelecky utok.
#define DISTANT(x) (((x)==atDistantAttack) || ((x)==atArcherAttack) || ((x)==atCatapultAttack) || ((x)==atMagicMissileAttack))

/** Typova sablona pro popis jednotky a RM.
  Pri nacteni mapy se vytvori pro kazdy typ jednotky sablona,
  ktera se zkopiruje a doplni pro kazdou konkretni instanci
  jednotky.
*/
struct TGUIUnitInfo{
  /// Charakteristicke vlastnosti typu jednotky.
  //@{
  int uid;									///< id typu jednotky
	//
  TModel* unit_model;       ///< model radovyho vojacka
  TModel* srgunit_model;    ///< model velitele
  int soundsid[10];         ///< pole idcek zvuku
  //
  TFormationType formation; ///< formace, podle typu jednotky
  TAttackType attackType;   ///< typ utoku jednotky
  int iMenInRow;
  float speed;              ///< rychlost, jednotky v ms~decimetry za ms
  //@}
	
  /// Pocatecni charakteristicke vlastnosti instance jednotky.
  //@{
  int iMenCount;            ///< pocet muzu v pripade regimentu, 1 v pripade infividualni formace
  int orientation;          ///< smer na hexu
  int hexx,hexy;            ///< hex umisteni
  int building;             ///< jednotka stavi
  int livingunit;           ///< idcko zivy jednotky
  int player;               ///< hrac kteremu jednotka patri
  //@}
};










/** Trida bojovnika. 
  Reprezentuje konkretni model bojovnika uvnitr jednotky. Tvori interface pro 
  vsechny akce, ktere muze panacek v gui delat(sermovat, umirat, krvacet,..).
  Je dost obecna, aby se dala pouzit na kazdy model. Pro specialni pripady se
  od ni da odvozovat. 
*/
class TUnitMember :public TModelSceneObject, public THighlighting, public TRefCounter
#ifdef SIMPLE_SHADOWS
, public TSimpleShadow
#endif
{
public:
  /// velikost osvetleni
  float fHighlightSize;
  /// nahodna diferenciace
  float fDiferentiate; 
  /// animace postavy
  TPuppetController* pc;
  /// pohyb na mape, planovac
  TUnitMemberController* umc;
  /// steering
  TSteeringController* sc;
  /// proxy objekt do ktereho patri
  TUnit* unit;
  /// stav panacka
  enum TUnitMemberState{umsLive, umsDead} umsState;
  /// pruhlednost
  float fTransparency;    
  /// konec posledni animace
  int iLastAnimationEnd;  
  
  /** Konstruktor.
    @param mid model vojacka
    @param cm koren hierarchie kontroleru
    @param u jednotka do ktere patri
  */
  TUnitMember(TModel *mid, TControllerManager* cm, TUnit* u);
  /** Destruktor.
    Odstrani ze sceny a odstrani kontrolery.
  */
  virtual ~TUnitMember();
  /** Vykresli model.
    Nastavi barvu materialu podle barvy vlastnika jednotky.
  */ 
	virtual void drawObject();

  /// Prehravani animaci, specielni akce a efekty.
  //@{
  /** Chuze.
  */
  void walk();
  /** Boj smerem k target(unitmember).
    @param target Cilovy panacek.
  */
  void fight(TUnitMember* target);
  /** Boj smerem k target(budova).
    @param target Cilova budova.
  */
  void fight(TBuilding* target);
  /** Strelba smerem k target(unitmember).
    @param target Cilovy panacek.
  */
  TDistant_Attack* fire(TUnitMember* target);
  /** Strelba smerem k target(budova).
    @param target Cilova budova.
  */
  TDistant_Attack* fire(TBuilding* target);
  /** Krvaceni.
    @param startAt Cas zacatku.
  */
  void bleed(int startAt = -1);
  /** Umirani.
    @param startAt Cas zacatku.
  */
  void die(int startAt = -1);
  /** Odeletet a zmizet.
    @param startAt Cas zacatku.
  */ 
  void flyAway(int startAt = -1);
  /** Zasah.
    @param startAt Cas zacatku.
  */
  void gothit(int startAt = -1);
  /** Zmizet.
  */
  void fadeout();
  /** Objevit se.
  */
  void fadein();
  //@}
  
  ///prehravani animaci, obecne
  //@{
  /** Prehraj animaci.
    @param id Idcko animace.
    @param flags Priznak (smycka, jednou,..)
    @param startAt Zacatek.
    @return Cas ukonceni animace.
  */
  int playAnimation(int id, int flags, int startAt);
  /** Zastav animaci.
    @param id Idcko animace.
    @param flag Priznak, zpusob zastaveni.
  */
  void stopAnimation(int id, int flag = PC_STOP_LOOPING);
  /** Zastav vsechny animace.
    @param flag Priznak, zpusob zastaveni.
  */
  void stopAllAnimations(int flag = PC_STOP_LOOPING);
  //@}

  ///pohyb po scene 
  //@{
  /** Chuze do dane draze.
    @param pos_c Pocet ridicich bodu.
    @param pos Ridici body.
    @param tangents Tecny.
    @param startAt Zacatek pohybu.
  */
  void go(int pos_c, P2F* pos, P2F* tangents, int startAt = -1);
  /** Presun z aktualni pozice
    @param pos pozice presunu
    @param dir smer presunu
    @param startAt cas zacatku.
  */
  void go(P2F* pos, P2F* dir, int startAt = -1);
  /** Naplanovani scenare.
    @param c Scenar.
    @param startAt Cas naplanovani. 
  */
  void script(TSceneScript* c, int startAt = -1);
  /** Zjisti smer.
    @param[out] dir Smer modelu.
  */
  void getDirection(P3F* dir);
  /** Zjisti velikost modelu.
    @param[out] dim Velikost podstavy modelu
  */
  void getModelDim(P2F* dim);
  /** Umisti a orientuje model ve scene.
    @param pos Pozice ve scene.
    @param dir Smer ve scene.
    @param up Up vektor.
  */
  void place(P3F* pos, P3F* dir, P3F* up);
  /** Nastavi pruhlednost.
    Vypne pritom vyber a osvetleni.
    @param t Uroven pruhlednosti.
  */
  void setTransparency(float t);
  //@}

  ///vyber - predavaji jednotce
  //@{
	virtual void onMouseOver();
	virtual void onClick();
  //@}

  ///zvyrazneni
  //@{
  virtual void drawHighlight();
  //@}

  ///ladici operace
  //@{
  /// Vykresli cesty steeringu.
  void drawPath();
  /// Vypise seznam naplanovanych akci.
  void dumpActions();
  //@}
  
  friend class TUnitMemberController;  
};












/** vektor clenu */
typedef std::list<TUnitMember*> vunitmember;

/** Jednotka.
  Proxyobjekt herni jednotky. Tvori interface pro akce, ktere muze jednotka 
  vykonat. Tyto akce se volaji primo z gui jako reakce na zpravy z worldu, 
  nebo reakce uzivatele. Spousti scene skripty.
*/
class TUnit: public TProxyObject, public TSelectableObject
{
public:
  ///obecny kontroler jednotky
  TUnitController* uc;
  ///formace jednotky
  TFormation* formation;
  ///clenove jednotky
  vunitmember vMembers;
  ///mrtvi clenove jednotky
  vunitmember vDeadMembers;
  ///pro ladeni, zakliknuty clen jednotky
  TUnitMember* subselectedmember;
  ///priznak, ze byla jednotka odstranena a az se odstrani vsichni clenova.. smaze se
  int iUninstalled;
  /** Konstruktor.
    @param sc scena
    @param info startovaci informace
  */
  TUnit(TguiMap* sc, TGUIUnitInfo* info);
  /** Destruktor.
    Zrusi vsechny data a kontrolery.
  */
  virtual ~TUnit();
  
  /// info
  //@{
  ///informace o jednotce, kopie sablony
  TGUIUnitInfo guiuiInfo;
  /** Pocet clenu jednotky.
    @return pocet clenu jednotky.
  */
  int getUnitMemberCount();
  /** Vrati formaci.
    @return Formace jednotky.
  */
  TFormation* getFormation();
  /** Pozice a orientace jednotky na 2D mape.
    @param[out] p pozice.
    @param[out] d smer
  */
  void getUnitPos(P2F* p, P2F* d);
  /** Ladici tisk.
    @param f soubor kam se ma tisknout.
  */
  virtual void dump2D(FILE* f);  
  //@}

  /// akce jednotky
  //@{
  /** Jdi po hexech.
    @param indx Pole indexu hexu po kterych ma jednotka jit.
    @param indx_c Velikost pole.
  */
  void gotoHex(int* indx, int indx_c);
  /** Jdi po ceste.
    Jednotk jde po hexech a updatuje viditelnost.
    @param path Cesta.
  */
  void gotoHex(TPath *path);
  /** Utok
    @param u  Jednotka oprance, nebo NULL v pripade budovy.
    @param b  Budova, nebo nul, pokud se utoci na jednotku.
    @param kills Pocet ztrat branici se jednotky.
    @param loss Pocet ztrat utocici jednotky.
    @param damage Poskozeni budovy.
    @param akilled Utocici jednotka je zjicena.
    @param dkilled Branici se jednotka je znicena. 
    @param bdestroyed Budova je znicena.
    @param ah Viditelnost utocnika.
    @param dh Viditelnost obrance.
  */
  void attack(TUnit* u, TBuilding* b, int kills, int loss, int damage,
              int akilled, int dkilled, int bdestroyed,
              TIntContainer* ah, TIntContainer* dh);              
  /** Sebevrazda jednotky.
    @param h Ztracena viditelnost.
  */
  void realeaseUnit(TIntContainer h);
  /** Stavba. 
    @param site_hex_indx Na kterym se stavi.
    @param living_building_id Id budovy ktera se stavi.
    @param lb Data budovy, ktera se stavi.
  */
  void build(int site_hex_indx, int living_building_id, World::LIVING_BUILDING* lb);
  /** Oprava budovy.
    @param bhex Index hexu
    @param b budova k opraveni
    @param s Seznam hexu, ktery se objevi.
    @param h Seznam hexu, ktery zmizi.
  */
  void repair(int bhex, TBuilding* b, TIntContainer s, TIntContainer h);  
  /** Leceni.
  */
  void heal();
  /** Rekrutovani vojaku.
    @param i Pocet novych vojaku.
  */
  void recruit(int i);  
  /** Zastaveni stavby/opravy.
  */
  void stopBuilding();
  /** Desertuj.
  */
  void desert();
  /** Zabij zranene panacky v jednotce.
    @param count Pocet zranenych panacku.
  */
  void membersDied(int count);

  //@}

  /// akce na objektu
  //@{
  /** Umisti jedntotku do budovy.
    @param b Budova.
  */
  void setInside(TBuilding* b);
  /** Viditelnost jednotky.
    @param f pruhlednost vsech clenu jednotky.
  */
  void transparency(float f);
  /** Odstran clena jednotky.
    @param um Clen.
  */
  void removeMember(TUnitMember* um);
  /** Pridej clena do jednotky.
    @param i Priznak, zda umistit do formace.
  */
  TUnitMember* addMember(int i);
  /** Spocitej orientaci. 
    @param dir Jeden z sesti smeru.
    @param[out] p Vektor orientace.
  */
  void calculateOrientation(int dir, P2F* p);
  /** Postav na hex.
    @param newindex index hexu.
  */
	virtual int addToHex(int newindex);
	/** Nastavi oslabeni objektu.
    @param newfade Uroven oslabeni.
  */
	virtual void setFade(int newfade);
  /** Casovy pomer.
    @param r novy casovy pomer vsech pridruzenych kontroleru.
  */
  void setTimeRatio(float r);
  //@}

  /// zpracovani vyberu
  //@{
	virtual void preselect();
	virtual void preunselect();
  virtual void select();
  virtual void unselect();
	virtual void onClick();
  //@}

  /// inicializace z RM
  //@{
  ///mapa pro typy jednotek
  static std::map<int, TGUIUnitInfo*> units; 
  /** Inicializace typu jednotek z rm.
  */
  static void initUnits();  
  /** Instalace jednotky.
    @param sc Mapa.
    @param lu_indx Idcko jednotky ve worldu.
    @param lu Struktura jednotky z worldu.
    @param x Souradnice x.
    @param y Souradnice y.
  */
  static TUnit* installUnit(TguiMap* sc, int lu_indx, World::LIVING_UNIT* lu, int x, int y);
  /** Odstran jednotku z mapy.
    @param sc Mapa.
    @param lu_indx Id jednotky ve worldu.
    @param dispose_unit Priznak, zda se ma natvrdo oznacit, nebo pockat na odstraneni vojacku.
  */
  static void uninstallUnit(TguiMap* sc, int lu_indx, int dispose_unit);
  /** Uvolni mapu jednotek.
  */
  static void freeUnits();  
  //@}

  //kamaradi
  friend class TUnitMember;
  friend class TFormation;

  //skripty
  friend class TCombat;
  friend class TCloseCombat;
  friend class TDistantCombat;
  friend class TOpenBuildingCombat;
  friend class TMarchMove;
  friend class TBuildingAttack;
  friend class TBuildBuilding;
  friend class TBlastAttack;
  friend class TReleaseUnit;
  friend class TRepairBuilding;
  friend class TUnitMemberDied;
  friend class TUnitDeserted;
};








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