/* ************************************************************************** */
/*                                         _____                              */
/*  Sprite.cpp                            |  ___| _   ____   ___              */
/*  Project : C-Engine                    | |_	 | | |  __| / _ \             */
/*                                        |  _|	 | | | |=  |  __/             */
/*  By: Fife <wasabifife@gmail.com>       |_|	 |_| |_|    \___|  	          */
/*                                                                            */
/*                                                                            */
/* ************************************************************************** */

#include "..\Rework\include\Components\Sprite.hpp"

    Sprite::Sprite()
    {
        Alpha = NULL;
        Beta = NULL;

        ReverseAlpha = NULL;
        ReverseBeta = NULL;
    }

    Sprite::Sprite(const unsigned char * v1, int sizex, int sizey , int bx , int by)
    {
        Beta=v1;
        size_x=sizex;
        size_y=sizey;

        b_x = bx;
        b_y = by;

        Alpha = NULL;

        ReverseAlpha = NULL;
        ReverseBeta = NULL;
    }

    Sprite::Sprite(const unsigned char * v1, const unsigned char * v2, int sizex, int sizey , int bx, int by)
    {
        Beta=v1;
        Alpha = v2;

        size_x=sizex;
        size_y=sizey;

        b_x = bx;
        b_y = by;

        ReverseAlpha = NULL;
        ReverseBeta = NULL;
    }

    void Sprite::DrawReverseSprite( int x , int y , int d)
    {
        switch(d)
        {
            case 90: if(size_y % 2  == 0)y --; break;
            case 180: if(size_y % 2  == 0)y --; if(size_x % 2  == 0)x --; break;
            case 270: if(size_x % 2  == 0)x --; break;
        }

        if(ReverseBeta)
        {
            if(ReverseAlpha)
            {
                ML_bmp_or_rotate((const unsigned char*) ReverseAlpha, x + br_x, y + br_y, size_x , size_y, d); // Affichage du canal alpha
                ML_bmp_and_rotate((const unsigned char*) ReverseBeta, x +br_x, y +br_y, size_x , size_y, d); // Affichage du sprite en entier
            }
            else
            {
                ML_bmp_or_rotate((const unsigned char*) ReverseBeta, x +br_x , y +br_y, size_x , size_y , d); // Affichage du sprite en entier
            }

        }
        else
        {
            DrawSprite( x , y , d);
        }
    }

    void Sprite::DrawSprite( int x , int y , int d)
    {
        switch(d)
        {
            case 90: if(size_y % 2  == 0)y --; break;
            case 180: if(size_y % 2  == 0)y --; if(size_x % 2  == 0)x --; break;
            case 270: if(size_x % 2  == 0)x --; break;
        }

        if(Beta)
        {
            if(Alpha)
            {
                ML_bmp_or_rotate((const unsigned char*) Alpha, x + b_x, y + b_y, size_x , size_y , d); // Affichage du canal alpha
                ML_bmp_and_rotate((const unsigned char*) Beta, x +b_x, y +b_y, size_x , size_y ,d); // Affichage du sprite en entier
            }
            else
            {
                ML_bmp_or_rotate((const unsigned char*) Beta, x +b_x , y +b_y, size_x , size_y , d); // Affichage du sprite en entier
            }

        }
    }

        void Sprite::CreateReverse( int brx , int bry)
    {
        int taille, lx , decalage;

        unsigned char transit;
        unsigned char out ;

        br_x = brx;
        br_y = bry;

        decalage = size_x % 8;

        lx = size_x / 8 + ( decalage != 0 );

        taille = lx * size_y;

        if(Beta)
        {
            ReverseBeta = (unsigned char*) malloc(sizeof(unsigned char) * taille);

            for( int i = 0 ; i < size_y ; i++ )
              for( int a = 0 ; a < lx ; a++ )
                ReverseBeta[i * lx + a] = Beta[ (i + 1) * lx - (a + 1)];

            for(int i = 0; i < taille ; i++)
             {
                 transit = ReverseBeta[i];

                 out = 0x0;

                 if((transit & 0x80) != 0x0)  out = out | 0x01;
                 if((transit & 0x40) != 0x0)  out = out | 0x02;
                 if((transit & 0x20) != 0x0)  out = out | 0x04;
                 if((transit & 0x10) != 0x0)  out = out | 0x08;
                 if((transit & 0x08) != 0x0)   out = out | 0x10;
                 if((transit & 0x04) != 0x0)   out = out | 0x20;
                 if((transit & 0x02) != 0x0)   out = out | 0x40;
                 if((transit & 0x01) != 0x0)   out = out | 0x80;

                 ReverseBeta[i] = out;
             }

            if(decalage)
            {
                 for(int i = 0 ; i < size_y ; i++ )
                    for(int a = 0 ; a < lx ; a++ )
                    {
                        transit = ((unsigned char)ReverseBeta[i * lx + a] >> ( decalage));

                        ReverseBeta[i * lx + a] = ((unsigned char)ReverseBeta[i * lx + a] << ( 8 - decalage));

                        if(a != 0)ReverseBeta[i * lx + a - 1] = ReverseBeta[i * lx + a - 1] | transit;
                    }

            }
        }


        if(Alpha)
        {
            ReverseAlpha = (unsigned char*) malloc(sizeof(unsigned char) * taille);

            for(int i = 0 ; i < size_y ; i++)
              for(int a = 0; a < lx; a++)
                ReverseAlpha[i * lx + a] = Alpha[ (i +1)*lx - (a+1)];

            for(int i = 0; i < taille ; i++)
             {
                 transit = ReverseAlpha[i];

                 out = 0x0;

                 if((transit & 0x80) != 0x0)  out = out | 0x01;
                 if((transit & 0x40) != 0x0)  out = out | 0x02;
                 if((transit & 0x20) != 0x0)  out = out | 0x04;
                 if((transit & 0x10) != 0x0)  out = out | 0x08;
                 if((transit & 0x08) != 0x0)   out = out | 0x10;
                 if((transit & 0x04) != 0x0)   out = out | 0x20;
                 if((transit & 0x02) != 0x0)   out = out | 0x40;
                 if((transit & 0x01) != 0x0)   out = out | 0x80;

                 ReverseAlpha[i] = out;
             }

        if(decalage)
        {
             for(int i = 0 ; i < size_y ; i++ )
                for(int a = 0 ; a < lx ; a++ )
                {
                    transit = ((unsigned char)ReverseAlpha[i * lx + a] >> ( decalage));

                    ReverseAlpha[i * lx + a] = ((unsigned char)ReverseAlpha[i * lx + a] << ( 8 - decalage));

                    if(a)ReverseAlpha[i * lx + a - 1] = ReverseAlpha[i * lx + a - 1] | transit;
                }

            }


        }


    }

    int Sprite::GetSizeY()
    {
        return size_y;
    }

    int Sprite::GetSizeX()
    {
        return size_x;
    }

    int Sprite::GetBlitX()
    {
        return b_x;
    }

    int Sprite::GetBlitY()
    {
        return b_y;
    }