################################################################################
#              script de gestion des apparences                                                                                      #
################################################################################
class Game_Apparence
  attr_accessor:sex
  attr_reader:name
  attr_accessor:nb
  attr_reader:color
  def initialize(name,sex=0,nb=0,r=255,g=255,b=255,a=255)
    @name=name
    @color=Color.new(r,g,b,a)
    @sex=sex%2
    @nb=nb
  end
  def existe?(partie)
    if @sex==0
      path="femme/"
    else
      path="homme/"
    end
    path2="./Apparences/fichier.exe " + "Apparences/Images/Personnages/" + path + @name + "/" + (@nb.to_s) + "/0.png"
    if system(path2)==false
      return false
    else
      return true
    end
  end
  def suiv
    @nb+=1
    if (existe?(self)==false)
    @nb-=1
  end
  return self
  end
  def prec
    @nb-=1
    if (existe?(self)==false)
    @nb+=1
  end
    return self
  end
  def switch_sex
    @sex=1-@sex
  end
  def change_color(color)
    @color=color
  end
  def save(myfile)
    temp= (@color.red.to_i.to_s)
    temp+="\n"
    temp+= (@color.green.to_i.to_s)
    temp+="\n"
    temp+= (@color.blue.to_i.to_s)
    temp+="\n"
    temp+= (@color.alpha.to_i.to_s)
    temp+="\n"
    if @sex==0
      temp+= "femme/"
    else
      temp+="homme/"
    end
    temp+= (@name)
    temp+="\n"
    temp+= (@nb.to_s)
    temp+="\n"
    myfile.write(temp)
  end
end
class Game_Perso
  def initialize(perso,sex=0)
    @perso=perso
    @data=[]
    @sex=sex%2
    @maj=false
  end
  def del(value)
    @maj=false
    for i in 0..@data.size-1
      if @data[i].name==value
        for j in i+1..@data.size-1
          @data[j-1]=@data[j]
        end
        @data[j]=nil
      end
    end
    return self
  end
  def [](value)
    @maj=false
    for i in 0..@data.size-1
      if @data[i].name==value
        return @data[i]
      end
    end
    @data[@data.size]=Game_Apparence.new(value,@sex)
   
    return @data[@data.size-1]
  end
  def switch_sex
    @sex=1-@sex
    return self
  end
  def refresh
    if @maj==false
      myfile=File.open("Apparences/ordres.cfg",'w')
      temp=(@data.size.to_s) + "\n"
      myfile.write(temp)
      for i in 0..@data.size-1
        @data[i].save(myfile)
      end
      myfile.close()
      temp="./Apparences/generateur.exe Graphics/Characters/" + @perso.character_name + ".png " + "/Images/Personnages/"
      system(temp)
      @maj=true
    end
  end
end

#ifndef ELEMENT_H_INCLUDED
#define ELEMENT_H_INCLUDED
class Element
{
    friend bool file_exist(std::string & s);
    public:
        //Constructeur
        Element(void);
        //Chargement des paramètres, et de l'image de l'élément.
        bool charger(ifstream &,string& path,Couleur & couleur);
        //Colle l'élément sur une surface.
        SDL_Surface * coller(SDL_Surface *);
        //Détruit l'élément
        ~Element(void);
        //Retourne le niveau de l'élément
        unsigned int retourne_niveau(void);
    private:
        void definirPixel(SDL_Surface * surface,int x, int y, Uint32 pixel);
        Uint32 Element::obtenirPixel(SDL_Surface * surface,int x, int y);
        bool blit(SDL_Surface * s);
        //Change la couleur de l'élément.
        bool colorier(Couleur &);
        //Stocke le niveau d'affichage de l'élément
        unsigned int niveau;
        //Stocke l'image de l'élément
        SDL_Surface * surface;
        //Stocke le fait si l'élément est propriétaire de la surface
        bool owner;
};
#endif // ELEMENT_H_INCLUDED

#ifndef ORDRE_H_INCLUDED
#define ORDRE_H_INCLUDED
#define TAILLE_MAILLON 50
class Partie;
class Ordre
{
    friend void Ordre::modifier_niveau(unsigned int);
    public:
        Ordre();
        ~Ordre();
        Ordre& operator<<(Partie&);
        SDL_Surface * generer(SDL_Surface *);
    private:
        void modifier_niveau(unsigned int);
        Ordre& operator<<(Element*);
        Ordre * suivant;
        Element * elements[TAILLE_MAILLON];

        unsigned int niveau;
};
#endif // ORDRE_H_INCLUDED

#ifndef PARTIE_H_INCLUDED
#define PARTIE_H_INCLUDED
class Ordre;
class Partie
{
    friend Ordre& Ordre::operator<<(Partie&);
    public:
        bool charger(ifstream &,char *, Ordre &);
        Partie(void);
        ~Partie(void);
    private:
        Couleur *couleur;
        unsigned int nombre_element;
        Element * elements;
};
#endif // PARTIE_H_INCLUDED

#ifndef COULEUR_H_INCLUDED
#define COULEUR_H_INCLUDED
class Couleur
{
    public:
        //Constructeur
        Couleur(void);
        //Chargement
        bool charger(ifstream &);
        //Coloriage d'une surface
        bool colorier(SDL_Surface * surface);
    private:
        void definirPixel(SDL_Surface * surface,int x, int y, Uint32 pixel);
        Uint32 obtenirPixel(SDL_Surface * surface,int x, int y);
        Uint8 rouge;
        Uint8 vert;
        Uint8 bleu;
        Uint8 opacite;
};
ifstream &operator>>( ifstream &out,Couleur &couleur);
#endif // COULEUR_H_INCLUDED

#ifndef PERSO_H_INCLUDED
#define PERSO_H_INCLUDED
class Perso
{
    public:
        Perso(char * path);
        ~Perso();
        void sauvegarder(char * filename);
    private:
        bool sauvegarder(SDL_Surface * surface);
        bool charger(ifstream &);
        SDL_Surface * surface;
        Ordre * ordre;
        Partie * parties;
        unsigned nombre_parties;
};
#endif // PERSO_H_INCLUDED

#ifndef UTILE_H_INCLUDED
#define UTILE_H_INCLUDED
bool file_exist(std::string & s);
#endif // UTILE_H_INCLUDED

#include <iostream>
#include <fstream>
#include <sstream>
using namespace std;
#include <SDL/SDL.h>
#include <SDL_image.h>
#include <libpng12/png.h>
#include "utile.h"
#include "couleur.h"
#include "Element.h"
#include "Ordre.h"
#include "Partie.h"
#include "Perso.h"
int main ( int argc, char** argv )
{
    if (argc<3)
        return 1;
    Perso P(argv[2]);
    P.sauvegarder(argv[1]);
    return 0;
}

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <SDL/SDL.h>
#include <SDL_image.h>
using namespace std;
#include "utile.h"
#include "couleur.h"
#include "Element.h"
#include "Ordre.h"
#include "Partie.h"
///Constructeur
Ordre::Ordre()
{
    suivant=NULL;
    niveau=0;
    for(unsigned int i=0;i<TAILLE_MAILLON;i++)
    {
        elements[i]=NULL;
    }
}
///Destructeur
Ordre::~Ordre()
{
    if (suivant!=NULL)
        delete[] suivant;
}
///On rajoute des élements
Ordre& Ordre::operator<<(Partie& partie)
{
    for(unsigned int i=0;i<partie.nombre_element;i++)
    {
        (*this)<<(partie.elements+i);

    }
    return *this;
}
Ordre& Ordre::operator<<(Element* element)
{
    unsigned int u=element->retourne_niveau();
    if (u>=(niveau+TAILLE_MAILLON))
    {
        if (suivant==NULL)
        {
            suivant=new Ordre[1];
            suivant->modifier_niveau(niveau+TAILLE_MAILLON);
        }
        (*suivant)<<element;
    }
    else
    {
        if (elements[u-niveau]==NULL)
            elements[u-niveau]=element;
        else
            cerr <<"Erreur: Deux éléments ont le même niveau!\n";
    }
    return *this;
}
///On génère la surface
SDL_Surface * Ordre::generer(SDL_Surface * surface)
{
    for(unsigned int i=0;i<TAILLE_MAILLON;i++)
    {
        if (elements[i]!=NULL)
            surface=elements[i]->coller(surface);
    }
    if (suivant!=NULL)
        surface=suivant->generer(surface);
    return surface;
}
void Ordre::modifier_niveau(unsigned int i)
{
    niveau=i;

}

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <SDL/SDL.h>
#include <SDL_image.h>
using namespace std;
#include "utile.h"
#include "couleur.h"
#include "Element.h"
#include "Ordre.h"
#include "Partie.h"
///Constructeur
Partie::Partie(void)
{
    couleur=NULL;
    nombre_element=0;
    elements=NULL;
}///Destructeur
///Destructeur
Partie::~Partie(void)
{
    if (couleur!=NULL)
    {
        delete[] couleur;
    }
    if (elements!=NULL)
    {
        delete[] elements;
    }
}
///Chargement
bool Partie::charger(ifstream & f,char * chemin, Ordre & ordre)
{
    string pat;
    string path(chemin);
    {
    ///Chargement des paramètres
    if (!f)
        return false;
    //chargement de la couleur
    couleur=new Couleur[1];
    f>>(*couleur);
    f>>pat;
    path="Apparences/" + path + "/" + pat;
    unsigned int caca=0;
    f>>caca;
    string path2=path+"/conf.cfg";
    ifstream g(path2.c_str(), ios::in);
    if (!g)
    {
        cerr <<"Erreur : Le fichier " <<path2<<" n'existe pas.\n";
        return false;
    }
    g>>nombre_element;
    elements=new Element[nombre_element];
    if (elements==NULL)
    {
        cerr <<"Erreur : Plus de mémoire disponible\n";
        return false;
    }
    for(unsigned int i=0;i<nombre_element;i++)
    {
        stringstream oss;
        oss << path<< "/" << caca<<"/" <<i << ".png";
        string path3=oss.str();
        elements[i].charger(g,path3,*couleur);
    }
    g.close();
    }
    ordre<<(*this);
    return true;
}

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
using namespace std;
#include <SDL/SDL.h>
#include <SDL_image.h>
#include <libpng12/png.h>
#include "utile.h"
#include "couleur.h"
#include "Element.h"
#include "Ordre.h"
#include "Partie.h"
#include "Perso.h"
///Gestion des PNG
static int png_colortype_from_surface(SDL_Surface *surface)
{
   int colortype = PNG_COLOR_MASK_COLOR; /* grayscale not supported */

   if (surface->format->palette)
      colortype |= PNG_COLOR_MASK_PALETTE;
   else if (surface->format->Amask)
      colortype |= PNG_COLOR_MASK_ALPHA;

   return colortype;
}
void png_user_warn(png_structp ctx, png_const_charp str)
{
   fprintf(stderr, "libpng: warning: %s\n", str);
}
void png_user_error(png_structp ctx, png_const_charp str)
{
   fprintf(stderr, "libpng: error: %s\n", str);
}
int png_save_surface(char *filename, SDL_Surface *surf)
{
   FILE *fp;
   png_structp png_ptr;
   png_infop info_ptr;
   int i, colortype;
   png_bytep *row_pointers;

   /* Opening output file */
   fp = fopen(filename, "wb");
   if (fp == NULL) {
      perror("fopen error");
      return -1;
   }

   /* Initializing png structures and callbacks */
   png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
      NULL, png_user_error, png_user_warn);
   if (png_ptr == NULL) {
      printf("png_create_write_struct error!\n");
      return -1;
   }

   info_ptr = png_create_info_struct(png_ptr);
   if (info_ptr == NULL) {
      png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
      printf("png_create_info_struct error!\n");
      exit(-1);
   }

   if (setjmp(png_jmpbuf(png_ptr))) {
      png_destroy_write_struct(&png_ptr, &info_ptr);
      fclose(fp);
      exit(-1);
   }

   png_init_io(png_ptr, fp);

   colortype = png_colortype_from_surface(surf);
   png_set_IHDR(png_ptr, info_ptr, surf->w, surf->h, 8, colortype,   PNG_INTERLACE_NONE,
      PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);

   /* Writing the image */
   png_write_info(png_ptr, info_ptr);
   png_set_packing(png_ptr);

   row_pointers = (png_bytep*) malloc(sizeof(png_bytep)*surf->h);
   for (i = 0; i < surf->h; i++)
      row_pointers[i] = (png_bytep)(Uint8 *)surf->pixels + i*surf->pitch;
   png_write_image(png_ptr, row_pointers);
   png_write_end(png_ptr, info_ptr);

   /* Cleaning out... */
   free(row_pointers);
   png_destroy_write_struct(&png_ptr, &info_ptr);
   fclose(fp);

   return 0;
}
///Constructeur
Perso::Perso(char * chemin)
{
    nombre_parties=0;
    parties=NULL;
    ordre=NULL;
    ifstream f("Apparences/ordres.cfg", ios::in);
    if (!f)
    {
        cerr <<"Erreur: Fichier d'ordre inexistant\n";
        return;
    }
    f>>nombre_parties;
    parties=new Partie[nombre_parties];
    if (!parties)
    {
        cerr <<"Erreur: Plus de mémoire disponible\n";
        return;
    }
    ordre=new Ordre[1];
    if (!ordre)
    {
        cerr <<"Erreur: Plus de mémoire disponible\n";
        return;
    }
    for( unsigned int i=0;i<nombre_parties;i++)
    {
        parties[i].charger(f,chemin,*ordre);
    }
    surface=ordre->generer(NULL);
    f.close();
}
///Destructeur
Perso::~Perso()
{
    if (parties!=NULL)
        delete[] parties;
    if (ordre!=NULL)
        delete[] ordre;
    if (surface!=NULL)
        SDL_FreeSurface(surface);

}
///Sauvegarde le perso
void Perso::sauvegarder(char * filename)
{
    if (surface!=NULL)
        png_save_surface(filename,surface);

}

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
using namespace std;
#include "utile.h"
bool file_exist(std::string & s)
{
    std::ifstream f(s.c_str());
    if (!f)
        return false;
    f.close();
    return true;
}

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <SDL/SDL.h>
#include <SDL_image.h>
using namespace std;
#include "couleur.h"
#include "Element.h"
///On définit un pixel
void Couleur::definirPixel(SDL_Surface * surface,int x, int y, Uint32 pixel)
{
    /*nbOctetsParPixel représente le nombre d'octets utilisés pour stocker un pixel.
    En multipliant ce nombre d'octets par 8 (un octet = 8 bits), on obtient la profondeur de couleur
    de l'image : 8, 16, 24 ou 32 bits.*/
    int nbOctetsParPixel = surface->format->BytesPerPixel;
    /*Ici p est l'adresse du pixel que l'on veut modifier*/
    /*surface->pixels contient l'adresse du premier pixel de l'image*/
    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;

    /*Gestion différente suivant le nombre d'octets par pixel de l'image*/
    switch(nbOctetsParPixel)
    {
        case 1:
            *p = pixel;
            break;

        case 2:
            *(Uint16 *)p = pixel;
            break;

        case 3:
            /*Suivant l'architecture de la machine*/
            if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
            {
                p[0] = (pixel >> 16) & 0xff;
                p[1] = (pixel >> 8) & 0xff;
                p[2] = pixel & 0xff;
            }
            else
            {
                p[0] = pixel & 0xff;
                p[1] = (pixel >> 8) & 0xff;
                p[2] = (pixel >> 16) & 0xff;
            }
            break;

        case 4:
            *(Uint32 *)p = pixel;
            break;
    }
}
///On récupère la valeur d'un pixel
Uint32 Couleur::obtenirPixel(SDL_Surface * surface,int x, int y)
{
    /*nbOctetsParPixel représente le nombre d'octets utilisés pour stocker un pixel.
    En multipliant ce nombre d'octets par 8 (un octet = 8 bits), on obtient la profondeur de couleur
    de l'image : 8, 16, 24 ou 32 bits.*/
    int nbOctetsParPixel = surface->format->BytesPerPixel;
    /* Ici p est l'adresse du pixel que l'on veut connaitre */
    /*surface->pixels contient l'adresse du premier pixel de l'image*/
    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;

    /*Gestion différente suivant le nombre d'octets par pixel de l'image*/
    switch(nbOctetsParPixel)
    {
        case 1:
            return *p;

        case 2:
            return *(Uint16 *)p;

        case 3:
            /*Suivant l'architecture de la machine*/
            if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
                return p[0] << 16 | p[1] << 8 | p[2];
            else
                return p[0] | p[1] << 8 | p[2] << 16;

        case 4:
            return *(Uint32 *)p;

        /*Ne devrait pas arriver, mais évite les erreurs*/
        default:
            return 0;
    }
}
///On change la couleur d'une surface
bool Couleur::colorier(SDL_Surface * surface)
{
    if (surface!=NULL)
    {
        for(int i=0;i<surface->w;i++)
        {
            for(int j=0;j<surface->h;j++)
            {
                /*Pour récupérer le code couleur d'un pixel*/
                Uint32 pixel=obtenirPixel(surface,i,j);
                Uint8 r1,g1,b1,a1;
                SDL_GetRGBA(pixel, surface->format, &r1, &g1, &b1, &a1);
                r1=(rouge*r1)/256;
                g1=(g1*vert)/256;
                b1=(b1*bleu)/256;
                a1=(a1*opacite)/256;
                pixel=SDL_MapRGBA(surface->format, r1, g1, b1, a1);
                /*Et pour changer la valeur d'un pixel*/
                definirPixel(surface,i,j,pixel);
            }
        }
    }
    else
    {
        cerr << "Impossible de recolorier la surface\nCause : La surface est vide\n";
        return false;

    }
    return true;
}
///Constructeur
Couleur::Couleur(void)
{
    rouge=0;
    vert=0;
    bleu=0;
    opacite=0;
}
///Chargement des couleurs
bool Couleur::charger(ifstream & file)
{
    unsigned int temp;
    if (!file)
        return false;
    file >> temp;
    rouge=temp;
    file>> temp;
    vert=temp;
    file >> temp;
    bleu=temp;
    file >> temp;
    opacite=temp;
    return true;
}
ifstream& operator>>(ifstream &file,Couleur &couleur)
{
    couleur.charger(file);
    return file;
}

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <SDL/SDL.h>
#include <SDL_image.h>
using namespace std;
#include "utile.h"
#include "couleur.h"
#include "Element.h"
///Constructeur
void Element::definirPixel(SDL_Surface * surface,int x, int y, Uint32 pixel)
{
    /*nbOctetsParPixel représente le nombre d'octets utilisés pour stocker un pixel.
    En multipliant ce nombre d'octets par 8 (un octet = 8 bits), on obtient la profondeur de couleur
    de l'image : 8, 16, 24 ou 32 bits.*/
    int nbOctetsParPixel = surface->format->BytesPerPixel;
    /*Ici p est l'adresse du pixel que l'on veut modifier*/
    /*surface->pixels contient l'adresse du premier pixel de l'image*/
    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;

    /*Gestion différente suivant le nombre d'octets par pixel de l'image*/
    switch(nbOctetsParPixel)
    {
        case 1:
            *p = pixel;
            break;

        case 2:
            *(Uint16 *)p = pixel;
            break;

        case 3:
            /*Suivant l'architecture de la machine*/
            if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
            {
                p[0] = (pixel >> 16) & 0xff;
                p[1] = (pixel >> 8) & 0xff;
                p[2] = pixel & 0xff;
            }
            else
            {
                p[0] = pixel & 0xff;
                p[1] = (pixel >> 8) & 0xff;
                p[2] = (pixel >> 16) & 0xff;
            }
            break;

        case 4:
            *(Uint32 *)p = pixel;
            break;
    }
}
///On récupère la valeur d'un pixel
Uint32 Element::obtenirPixel(SDL_Surface * surface,int x, int y)
{
    /*nbOctetsParPixel représente le nombre d'octets utilisés pour stocker un pixel.
    En multipliant ce nombre d'octets par 8 (un octet = 8 bits), on obtient la profondeur de couleur
    de l'image : 8, 16, 24 ou 32 bits.*/
    int nbOctetsParPixel = surface->format->BytesPerPixel;
    /* Ici p est l'adresse du pixel que l'on veut connaitre */
    /*surface->pixels contient l'adresse du premier pixel de l'image*/
    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;

    /*Gestion différente suivant le nombre d'octets par pixel de l'image*/
    switch(nbOctetsParPixel)
    {
        case 1:
            return *p;

        case 2:
            return *(Uint16 *)p;

        case 3:
            /*Suivant l'architecture de la machine*/
            if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
                return p[0] << 16 | p[1] << 8 | p[2];
            else
                return p[0] | p[1] << 8 | p[2] << 16;

        case 4:
            return *(Uint32 *)p;

        /*Ne devrait pas arriver, mais évite les erreurs*/
        default:
            return 0;
    }
}
///On change la couleur d'une surface
bool Element::blit(SDL_Surface * s)
{
    if (surface!=NULL)
    {
        for(int i=0;i<s->w;i++)
        {
            for(int j=0;j<s->h;j++)
            {

                /*Pour récupérer le code couleur d'un pixel*/
                Uint32 pixel=obtenirPixel(s,i,j);
                Uint32 pixel2=obtenirPixel(surface,i,j);
                Uint8 r1,g1,b1,a1;
                SDL_GetRGBA(pixel, s->format, &r1, &g1, &b1, &a1);
                Uint8 r0,g0,b0,a0;
                SDL_GetRGBA(pixel2, surface->format, &r0, &g0, &b0, &a0);
                r1=(r0*a0)/255.0 + ((255-a0)*a1*r1)/(255.0*255.0);
                g1=(g0*a0)/255.0 + ((255-a0)*a1*g1)/(255.0*255.0);
                b1=(b0*a0)/255.0 + ((255-a0)*a1*b1)/(255.0*255.0);
                if (a1<a0)
                {
                    a1=a0;
                }
                pixel=SDL_MapRGBA(surface->format, r1, g1, b1, a1);
                /*Et pour changer la valeur d'un pixel*/
                definirPixel(s,i,j,pixel);
            }
            cerr <<"\n";
        }
    }
    else
    {
        cerr << "Impossible de recolorier la surface\nCause : La surface est vide\n";
        return false;

    }
    return true;
}
Element::Element(void)
{
    //Mise des pointeurs à NULL pour détecter s'ils ont étés alloués!
    surface=NULL;
    owner=true;
    //Mise du niveau à 0.
    niveau=0;
}
///Chargement de l'élément
bool Element::charger(ifstream & file,string& path,Couleur& couleur)
{
    ///Chargement des paramètres
    {
    //Si le fichier n'a pas été ouvert!
    if (!file)
    {
        return false;
    }
    //Chargement du niveau
    file >> niveau;
    }
    ///Chargement de l'image
    {
    //Test si le fichier existe
    if (!file_exist(path))
    {
        cerr <<"Erreur: Le programme n'arrive pas à lire:" <<path<<"\n";
        return false;
    }
    //Charge la Surface
    surface=IMG_Load(path.c_str());
    //Teste si la surface a été chargée.
    if (surface==NULL)
    {
        cerr << SDL_GetError() << "\n";
        return false;
    }
    }
    ///Coloriage de l'image
    {
        return colorier(couleur);
    }
}
///Collage de l'élément sur une surface
SDL_Surface * Element::coller(SDL_Surface * s)
{
    ///Teste si la surface est non vide
    {
        if (s==NULL)
        {
            if (surface!=NULL)
            {
                s=SDL_CreateRGBSurface(SDL_HWSURFACE||SDL_SRCALPHA, surface->w, surface->h,surface->format->BitsPerPixel, surface->format->Rmask, surface->format->Gmask, surface->format->Bmask, surface->format->Amask);
                SDL_FillRect(s, NULL, SDL_MapRGBA(s->format, 0, 0, 0,0));
            }

        }
    }
    if (surface==NULL)
        return s;
    ///Colle l'élément sur la surface s
    {
        SDL_Rect p;
        p.x=0;
        p.y=0;
        blit(s);
    }
    return s;
}
///Destructeur
Element::~Element(void)
{
    ///Libération de la surface
    {
        if (surface!=NULL && owner)
            SDL_FreeSurface(surface);
    }

}
///Permet de colorier l'élément
bool Element::colorier(Couleur & couleur)
{
    if (!surface)
    {
        return false;
    }
    return couleur.colorier(surface);
}
///Retourne le niveau
unsigned int Element::retourne_niveau(void)
{
    return niveau;
}