#ifndef MADMAP
#define MADMAP 1


#include "Area.h"
#include "MarbleTriangle.h"
#include "MadUtility.h"
using namespace std;

//=======================MadMap====================
//Mappa del gioco, composta da una griglia di Tile
//=================================================
class MadMap 
{
public:
     

     //===================================
     //Posizione di partenza della pallina
     //===================================
     Area Start;



     //===================================
     //Area della mappa visualizzata con 
     //un diverso colore
     //===================================
     Area Colored;

     //===================================
     //indica se la mappa è valida o no
     //===================================
      bool Meaningful;


   

     //===================================
     //vettore di pos di partenza dei nemici                  //notaaaaaaaa
     //===================================
     Area Enemys[MAXENEMY ]; 


    

     //===================================
     //Matrice di Tile.               <br>
     //contiene tutte le altezze delle
     //piastrelle della mappa        
     //===================================
     MadTile Map[MAXMAP][MAXMAP] ;


     //======================
     //vettore id Texture
     //======================
     GLuint ti[MAXMAP]; 

     //========================================
     //Le Normali per ogni triangoli delle tile
     //========================================
     Point3f Nl[MAXMAP][MAXMAP][4];
     
     //========================================
     //Vettore con i nomi delle texture
     //========================================
     char Tex[MAXMAP][120];

     //========================================
     //id delle texture dei nemici
     //========================================
     int TexEnemy;

     //===========================================
     //numero delle texture utilizzate dalla mappa
     //===========================================
     int numtex;
     //===================================
     //Dimenzione della matrice
     //(Dim.X)x(Dim.Z)
     //===================================
     coord Dim;
    
    
private:

    //==========================================
    //serve per definire la texture per la Tile
    //==========================================
    Area Default;
    
    //==========================================
    //serve per definire la texture per il muro <br>
    // di dislivello tra le Tile
    //==========================================
    Area Wall;

    
public:
    //===================Costruttore============================
    //costruisce una mappa non valida
    //==========================================================
    MadMap();

    //===================Costruttore============================
    //costruisce una mappa valida di grandezza (SizeX)x(SizeZ)
    //dove l'altezza di ogni tile è DEFAULT_Y e l'are Goal e
    //lo Start non sono indicati                            <br>
    //                                                      <br>
    //Parametri                                             <br>
    //SizeX: grandezza X della mappa                        <br>
    //SizeZ: grandezza Z della mappa    
    //==========================================================
    MadMap(int SizeX,int SizeZ);

    /**Distruttore*/
    ~MadMap(){};

    //===================Draw===================================
    //Disegna la mappa nell'ambiente OpenGl.                <br>
    //                                                      <br>
    //Parametri                                             <br>
    //option: WIREFRAME disegna la mappa a 
    //              "fil di ferro" colorato                 <br>
    //        SOLID disegna la mappa "Solida" senza texture <br>
    //        TEXTURED  disgna la mappa "solida" con texture <br>
    //==========================================================
    void Draw(int option);

    //===================DrawWall===============================
    //Disegna un muro                                       <br>
    //                                                      <br>
    //Parametri                                             <br>
    //x,y: le coordinate della tile nella mappa             <br>
    //side: lato nella tile (NORTH, SOUTH , EAST, WEST)     <br>
    //option: WIREFRAME, SOLID, TEXTURED                    <br>
    //==========================================================
    void DrawWall(int x,int z,int side,int option);

    //===================DrawTile===============================
    //Disegna un tile                                       <br>
    //                                                      <br>
    //Parametri                                             <br>
    //x,y: le coordinate della tile nella mappa             <br>
    //option: WIREFRAME, SOLID, TEXTURED                    <br>
    //==========================================================
    void DrawTile(int x,int z, int option);

    //===================XMLWrite===============================
    //Salva la mappa in un file di formato XML              <br>
    //                                                      <br>
    //Parametri                                             <br>
    //fp : puntatore al file per il salvataggio
    //==========================================================
    void XMLWrite(FILE *fp);

    //===================XMLRead================================
    //Costruisce la mappa attraverso un documento XML       <br>
    //                                                      <br>
    //Parametri                                             <br> 
    //xml : puntatore ad un oggetto xml
    //==========================================================
    void XMLRead(vcg::Xml &xml);

    /**non implementato*/
    void reSize(int SizeX,int SizeZ);

    //===================getY===================================
    //restituisce l'altezza (Y) nel punto X, Z nella mappa
    //  se non appartiene alla mappa valore restituito -200
    //==========================================================
    double getY(double X, double Z);

    //==========================================================
    //restituisce il triangolo della tile in riferimento alle
    //coordinate X, Z
    //==========================================================
    void getTriangle(double X, double Z, MarbleTriangle *currentTriangle  );

    //===================setY===================================
    //cambia il valore a Y del campo(NO,NE,SO,SE) della tile più 
    // vicina al punto nella mappa indicato da X e Z
    //==========================================================
    void setY(double X, double Z, double Y);

    //===================copy===================================
    //permette di copiare in map_copy l'area definita dalle 
    //coordinate first e last
    //==========================================================
    void copy ( MadMap *map , coord first , coord last);

    //===================copy===================================
    //permette di l'intera MadMap in map_copy
    //==========================================================
    void copy (MadMap *map);

    //===================paste==================================
    //cambio l'area nella mappa definita dalle coordinate first 
    // e last con la mappa contenuta in map_paste
    //==========================================================
    void paste ( MadMap *map , coord first , coord last );

    //===================merge==================================
    //aggiungo nell'area nella mappa definita dalle coordinate 
    // first e last la mappa contenuta in map_paste
    //==========================================================
    void merge ( MadMap *map , coord first , coord last );

    //===================upTile=================================
    //alza la tile alle coordinate X, Y nella mappa di un 
    // altezza Y
    //==========================================================
    void upTile(int X,int Z,double Y);
    
    //===================zeroTile===============================
    //pone ad un'altezza k la tile alle coordinate X, Y
    //==========================================================
    void zeroTile(int X,int Z,double k);
    
    //===================PickElement============================
    //PickElement nella Mappa.                              <br>
    //                                                      <br>
    //valore restituito.                                    <br>
    //se >-1                                                <br>
    // allora un intero dove il modulo 100 è la coordinata X 
    // della tile "pickata"                                 <br>
    //mentre la divisione intera per 100 è la coordinata Z 
    //della tile "pickata"                                  <br>
    //se =-1 nessuna tile!                                  <br>
    //                                                      <br>
    //Parametri                                             <br>
    //x:coordinata x della vista x su cui fare la pick      <br>
    //y: coordinata y della vista su cui fare la pick       <br>
    //option: specifica se il disegno avviene tramite 
    // WIREFRAME o SOLID
    //==========================================================
    int PickElement(int x, int y, int option);
    
    //======================InitTexture=========================
    //inizializza le texture di tutte le aree della mappa
    //==========================================================
    void InitTexture(void);

    //======================setColoredArea======================
    //definisce con le coordinate a, b l'area colorata
    //diversamentea all'interno della mappa
    //==========================================================
    void setColoredArea(coord a, coord b);

    //======================isColored===========================
    //verifica se il punto x, z nella mappa è nell'area 
    //colorata                                              <br>
    //valore restituito: true se appartiene all'area colorata, 
    //false altrimenti 
    //==========================================================
    bool isColored(double x, double z);

    //=====================getColoredGravity====================
    //restituisce il valore della 
    // gravità nell'area colorata nella mappa
    //==========================================================
    int getColoredGravity();

    //=====================getColoredAttrito====================
    //restituisce il valore del 
    // Attrito nell'area colorata nella mappa
    //==========================================================    
    int getColoredAttrito();

    //=====================getColoredTexWall====================
    //restituisce il valore del 
    // id della texture del muro nell'area colorata nella mappa
    //==========================================================    
    int getColoredTexWall();

    //=====================getColoredTexTile=====================
    //restituisce il valore del 
    // id della texture delle tile nell'area colorata nella mappa
    //===========================================================
    int getColoredTexTile();

    //=====================CalcNorm==============================
    //Calcola le normali della mappa. il risultati in Nl
    //===========================================================
    void CalcNorm();

    //=====================intersect=============================
    //Verifica se il segmento definito dai punti (x1,y1,z1) e
    // (x2,y2,z2) intersechi con la mappa.
    // se si restuisce TRUE
    // se no FALSE
    //===========================================================
    bool intersect(float x1,float y1,float z1,float x2, float y2,float z2);

};


#endif