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

  @file /gui/engine/SceneScripts.h
  @brief Formace jednotky, razeni vojacku v utvarech, boj, stavba
  

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

#include "common/mm.h"
//
#include "gui/common/mymath.h"
#include "gui/model/UnitFormation.h"
#include "world/typedefs.h"
//

namespace gui{

//FWD
class TUnit;
class TUnitMember;
class TBuilding;

/// Skriptovatelny objekt.
typedef void* TScriptedObject;

/** Predchudce pro scenare.
  Trida, ktera funguje jako scenar pro deje na virtualni scene.
  Tato trida je abstraktni.
*/
class TSceneScript: public TRefCounter
{
public:
  /// Scena na ktere probiha scenar.
  TguiMap* guimap;
  /** Destruktor.
    Stara se o odstraneni instance ze statickeho seznamu 
    vSceneScriptInstances aktivnich instanci.
  */
  virtual ~TSceneScript();
  /** Konstruktor.
    @param scene Scena na ktere se skript odehrava.
  */
  TSceneScript(TguiMap* scene);
  /** Prechodova funkce.
    Jeden krok scenare objekt.
    @param so Skriptovany objekt.
  */
  virtual void decision(TScriptedObject* so) = 0;
  /** Stav skriptu.
    @param buff Zasobnik pro text.
    @param size Maxilalni velikost zasobniku.
    @return Delka zpravy.
  */
  virtual int getStatusMsg(char* buff, int size) = 0;

  /// Vektor instanci.
  static std::vector<TSceneScript*> vSceneScriptInstances;
  /** Vypis aktivnich instanci.
    Vypise instance v vSceneScriptInstances. Pro ladici ucely.
  */
  static void report();
};


/** Stavova struktura bojovnika.
  Pro bojove scenare. Obalka bojovnika.
*/
struct TCombatant{
  TUnitMember* um;          ///< identifikace a aktualni pozice
  TUnitMemberPosition ump;  ///< cilova pozice
  int defender;             ///< obrance
  int defendpos;            ///< v obrane pozici
  int attackpos;            ///< v utocne pozici
  int counterattack;        ///< uz protiutocil?
  TBuilding* inbuilding;    ///< v budove?
  int dead;                 ///< mrtvy
  int slaughtered;          ///< zrovna zabijen => nevybirat jako cil utoku
  int finished;             ///< ukoncil scenar
  TCombatant* opponent;     ///< protivnik
};


/** Obecny soubojovy scenar. */
class TCombat: public TSceneScript
{
public:
  /// Data pro souboje.
  //@{
  TUnit* uAttacker;   ///< utocici jednotka
  TUnit* uDefender;   ///< branici se jednotka
  int iAttackerKills; ///< pocet zabitych vojaku
  int iAttackerLoss;  ///< pocty ztracenych vojaku
  //
  bool bAttackerKilled;  ///< priznak, utocnik rozprasen
  bool bDefenderKilled;  ///< priznak, obrance rozprasen
  //
  int iBuildingDamaged;     ///< poskozeni budovy
  bool bBuildingDestroyed;  ///< priznak, budova znicena
  //
  TBuilding* bAttackerBuilding; ///< utocnik vybehl z budovy
  TBuilding* bTargetBuilding;   ///< cil utoku
  //
  TIntContainer attacker_hidden;  ///< ztrata vyhledu utocnika
  TIntContainer defender_hidden;  ///< ztrata vyhledu obrance
  //
  int aplayer, dplayer;               ///< pamet na idcka hracu
  std::vector<TCombatant> combatants; ///< seznam bojovniku
  //@}
  
  /** Spocita utocniky.
    @return Pocet utocniku.
  */
  int attackers();
  /** Spocita obrance.
    @return Pocet obrancu.
  */
  int defenders();
  /** Konstruktor.
    @see TSceneScript
  */
  TCombat(TguiMap* scene);
  /** Konstruktor.
    Univerzalni pro vsechny souboje.
    @see TSceneScript
  */
  TCombat( TUnit* attacker, TUnit* defender, TBuilding* b, 
           int kills, int loss, bool ak, bool dk, 
           int bdamaged, bool bdestroyed, 
           TIntContainer* ah, TIntContainer* dh);
  /** Destruktor.
  */
  virtual ~TCombat();
  /** Najdi pozici pro bojovnika.
    @param c Stav bojovnika.
    @param ump Vystup, pozice.
    @param enemy Vystup, bojovnik na ktereho se utoci.
  */
  void findCombatantPosition(TCombatant* c, TUnitMemberPosition* ump, TCombatant** enemy);
  /** Najdi nahodnou skupinu bojovniku.
    @param size Velikost skupiny.
    @return Vektor nalezenych bojovniku.
  */
  std::vector<TCombatant*> findRandomVictimGroup(int size);
  /** Najdi nahodneho ziveho bojovnika.
    @param defender Priznak zda ma byt bojovnik obrance.
    @return Nalezeny bojovnik.
  */
  TCombatant* findRandomCombatant(int defender);
  /** Najdi bojovnika podle skriptovaneho objektu.
    @param um Model bojovnika.
    @return Bojovnik odpovidajici skriptovanemu objektu.
  */
  TCombatant* getCombatant(TUnitMember* um);
  /** Najdi polohu pro bojovnika ve formaci.
    @param c Bojovnik.
    @param ump Vystup, pozice ve formaci.
  */
  void findFormationPosition(TCombatant* c, TUnitMemberPosition* ump);
  /** Inicializuj strukturu pro bojovnika.
    @param c Bojovnik.
    @param um Skriptovany objekt.
    @param defender Priznak zda je objekt obrance.
  */
  virtual void initCombatant(TCombatant* c, TUnitMember* um, int defender);
  /** Odstraneni objektu odpovidajici strukturu bojovnika.
    @param so Skriptovany objekt.
  */
  virtual void leavescript(TScriptedObject* so);
  /** Vygeneruje zpravu o stavu skriptu.
    @see TSceneScript    
  */
  virtual int getStatusMsg(char* buff, int size);
};


/** Scenar pro boj na blizko. */
class TCloseCombat: public TCombat
{
public:
  /** Prechodova funkce.
    @see TSceneScript
  */
  virtual void decision(TScriptedObject* so);
  /** Konstruktor.
    @param attacker Utocnik.
    @param defender Obrance
    @param kills Kolik zabije utocnik. 
    @param loss Kolik zabije obrance.
    @param ak Utocnik umre.
    @param dk Obrance umre.
    @param ah Viditelnost utocnika.
    @param dh Viditelnost obrance.
  */
  TCloseCombat( TUnit* attacker, TUnit* defender, 
                int kills, int loss, bool ak, bool dk,
                TIntContainer* ah, TIntContainer* dh);
};

/** Scenar pro boj na dalku. */
class TDistantCombat: public TCombat
{
public:
  /** Prechodova funkce.
    @see TSceneScript
  */
  virtual void decision(TScriptedObject* so);
  /** Zniceni budovy.
  */
  void buildingDestroyed();
  /** Konstruktor.
    @see TCombat
  */
  TDistantCombat( TUnit* attacker, TUnit* defender, TBuilding* b, 
                  int kills, int loss, bool ak, bool dk, 
                  int bdamaged, bool bdestroyed,
                  TIntContainer* ah, TIntContainer* dh);
};


/** Scenar pro boj z/do otevrene budovy. */
class TOpenBuildingCombat: public TCombat
{
public:
  /// Prechodova funkce pro obrance.
  void DEFENDER_decision(TCombatant* c);
  /// Prechodova funkce pro utocnika.
  void ATTACKER_decision(TCombatant* c);
  /// Prechodova funkce pro budovu.
  void BUILDING_decision();

  /** Prechodova funkce.
    @see TSceneScript
  */
  virtual void decision(TScriptedObject* so);  
  /** Zniceni bodovy.
  */
  void buildingDestroyed();
  /** Konstruktor.
    @see TCombat
  */
  TOpenBuildingCombat(TUnit* attacker, TUnit* defender, TBuilding* b, 
                      int kills, int loss, bool ak, bool dk, 
                      int bdamaged, bool bdestroyed,
                      TIntContainer* ah, TIntContainer* dh);
};


/** Scenar pro utok na budovu, z pole i z budovy. */
class TBuildingAttack: public TCombat
{
public:
  /** Zniceni bodovy.
  */
  void buildingDestroyed();
  /** Prechodova funkce.
    @see TSceneScript
  */
  virtual void decision(TScriptedObject* so);
  /** Konstruktor.
    @see TCombat
  */
  TBuildingAttack(TUnit* attacker, TUnit* defender, TBuilding* b, 
                  int kills, int loss, bool ak, bool dk, 
                  int bdamaged, bool bdestroyed,
                  TIntContainer* ah, TIntContainer* dh);
};


/** Utok vybuchem. */
class TBlastAttack: public TCombat
{
public:
  /** Prechodova funkce.
    @see TSceneScript
  */
  virtual void decision(TScriptedObject* so);
  /** Konstruktor.
    @see TCombat
  */
  TBlastAttack( TUnit* attacker, TUnit* defender, TBuilding* b, 
                int kills, int loss, bool ak, bool dk, 
                int bdamaged, bool bdestroyed,
                TIntContainer* ah, TIntContainer* dh);
};

/** Scenar pro pohyb jednotky, vyresi budovy, teren. */
class TMarchMove: public TSceneScript{
public:
  TUnit* unit;  ///< jednotka, ktera se hybe
  int umleft;   ///< kolik jednotek zbyva
  int hexReached;   ///< Hex na ktery se prislo(=pozice v ceste)
  TPath marchPath;  ///< Cesta
  /** Prechodova funkce.
    @see TSceneScript
  */
  virtual void decision(TScriptedObject* so);
  /// Stav.
  virtual int getStatusMsg(char* buff, int size);
  /// Naplanuje cestu centralne do formace.  
  void moveToFormation();
  /** Vlez do budovy.
    @param b Budova.
    @param in_dir Smer ze ktereho prichazim.
  */
  void getInside(TBuilding* b, P2F* in_dir);
  /** Vylez z budovy.
    @param b Budova.
    @param out_dir Smer do ktereho odchazim.
  */
  void getOutside(TBuilding* b, P2F* out_dir);  
  /** Naplanuj dalsi segment cesty.
    Odkryva mapu.
    @param curr_step Aktualni hex.
    @param next_step Nasledujici hex.
  */
  void planSegment(TStep* curr_step, TStep* next_step);
  /** Pochod.
    @param u Jednotka.
    @param path Cesta.
  */
  TMarchMove(TUnit* u, TPath *path);
};


/** Scenar pro stavbu budovy. */
class TBuildBuilding: public TSceneScript{
public:
  TUnit *uBuilder;            ///< jednotka stavitele
  TBuilding *bSourceBuilding; ///< budova ze ktere vyleza, nebo NULL
  TBuilding* bBuilding;       ///< stavena budova
  THex* hSite;                ///< hex kde se ma stavet

  /// stavova promenna ze je stavitel na miste kde ma stat
  std::map<TScriptedObject, int> builder_at_position;  
  /** Presun jednotku do pozice stavitele.
    @param umb Clen jednotky stavitele.
  */
  void goToBuilderPosition(TUnitMember* umb);
  /** Prechodova funkce.
    @see TSceneScript
  */
  virtual void decision(TScriptedObject* so);
  virtual int getStatusMsg(char* buff, int size);
  //
  TBuildBuilding(TUnit* builder, TBuilding* building, THex* sitehex);
};

/** Scenar pro uvolneni jednotky. */
class TReleaseUnit: public TSceneScript{
public:
  /// vyrobi skript pro jednotku u
  TReleaseUnit(TUnit* u, TIntContainer h);
  /** Prechodova funkce.
    @see TSceneScript
  */
  virtual void decision(TScriptedObject* so);
  ///stav skriptu
  virtual int getStatusMsg(char* buff, int size);  
};


/** scenar pro demolici budovy */
class TDemolishBuilding: public TSceneScript{
public:
  /** Konstruktor.
    Vyrobi skript pro zniceni budovy a zakryti mapy.
    
    @param b Budova, ktera se ma znicit.
    @param h Indexy hexu, ktere se maji zakryt.
  */
  TDemolishBuilding(TBuilding* b, TIntContainer h);
  /** Prechodova funkce.
    @see TSceneScript
  */
  virtual void decision(TScriptedObject* so);
  ///stav skriptu
  virtual int getStatusMsg(char* buff, int size);  
};

/** Scenar pro opravu budov. */
class TRepairBuilding: public TSceneScript{
public:
  /// budova, ktera se ma opravit
  TBuilding* bBuilding;
  /// budova, ze ktere stavitel vyleza, nebo NULL
  TBuilding* bSourceBuilding;
  /// stavitel
  TUnit* uBuilder;
  /// stavova promenna ze je stavitel na miste kde ma stat
  std::map<TScriptedObject, int> builder_at_position;  
  /** Konstruktor. 
    Vyrobi skript pro jednotku opravujici budovu.    
    @param builder Stavitel.
    @param building Budova    
    @param s Objevene hexy    
    @param h Zmizele hexy    
  */
  TRepairBuilding(TUnit* builder, TBuilding* building, TIntContainer s, TIntContainer h);
  /** Prechodova funkce.
    @see TSceneScript
  */
  virtual void decision(TScriptedObject* so);
  ///stav skriptu
  virtual int getStatusMsg(char* buff, int size);  
};


/** Scenar pro deserci jednotky. */
class TUnitDeserted: public TSceneScript{
public:
  /// vyrobi skript pro jednotku u
  TUnitDeserted(TUnit* u, TIntContainer h);
  ///stavova funkce 
  virtual void decision(TScriptedObject* so);
  ///stav skriptu
  virtual int getStatusMsg(char* buff, int size);  
};


/** Scenar pro umirani zranenych panacku. */
class TUnitMemberDied: public TSceneScript{
public:
  /// vyrobi skript pro jednotku u
  TUnitMemberDied(TUnit* u, int count);
  ///stavova funkce 
  virtual void decision(TScriptedObject* so);
  ///stav skriptu
  virtual int getStatusMsg(char* buff, int size);  
};

//class TCastSpell: public TSceneScript{};

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