#include "Script_Control.hpp"

#include "IA_Monstre.hpp"

//Kirby script

void Control::Start()
{
    isground = false;
    isdo = false; // Si réalise une action True
    isaspi = false;
    isfull = 0;
    ishurt = 0;

    couldown = 0;

    direction = 0;

    GetEngine()->AddObject(OAspi);

    GetObject()->AddRigidBody();
    GetObject()->GetRigidBody()->SetMass(2);
    GetObject()->GetRigidBody()->UseFixeBody(16,16);

    GetObject()->AffectTag("Kirby");

    oldx = GetX();
    oldy = GetY();

    boss = false;
}

void Control::Teleport( int x , int y , int level )
{
    if(input_trigger(K_UP))
    {
        GetEngine()->GetCurrentLevel()->DrawLevel();

        for(int i = 0 ; i < 190 ; i ++)
        {
            ML_line(-1,i,i,-1,ML_BLACK);
            ML_display_vram();
            Sleep(3);
        }


        GetEngine()->MoveObject(GetObject(),level);
        GetEngine()->MoveObject(OAspi,level);
        GetEngine()->SetCurrentLevel(level);
        SetXY(x,y);

        input_update();
    }
}

void Control::Update()
{
    if(couldown)couldown--;

    boss = false;

    for(int i = 0 ; i < GetEngine()->GetCurrentLevel()->GetNbObject() ; i++ )
    {
        if(!strcmp(GetEngine()->GetCurrentLevel()->GetListeObject()[i]->GetTag(), "Boss")) boss = true;
    }


    if(GetEngine()->GetIdCurrentLevel() < 3 && !boss)GenerateMonster();

    //Check si on touche le sol ou une plateforme

    isground = CollisionDecor( GetX() , GetY() - 1 );

    if(!mod(GetY() , 16)  && GetBody()->velocity.y < 11 )
    {
        int cas1 = GetEngine()->GetCurrentLevel()->GetIdMap( GetX() , GetY() - 1 , true );
        int cas2 = GetEngine()->GetCurrentLevel()->GetIdMap( GetX() + 16 , GetY() - 1 , true );

        if(cas1 == 58)cas1 = 56;
        if(cas2 == 58)cas2 = 56;

        if(cas1 == 56 || ( mod(GetX() , 16) && cas2 == 56) )
        {
            GetBody()->velocity.y = 10;
            isground = true;

            if(input_press(K_DOWN))
            {
                GetBody()->velocity.y = - 11;
                isground = false;
            }
        }
    }

    //Initialise à 0 l'action du joueur

    isdo = false;

    //On vérifie si le joueur n'a pas pris un dégat

    if(ishurt)//Si oui allors on le recule
    {
        GetObject()->GetRender()->ForceSetIt(2);

        if(ishurt > 15)
        {
            GetBody()->velocity.x = 40 * ((direction) - (!direction));
            GetBody()->velocity.y = 45;
        }
        else
        {
            GetBody()->velocity.x = 0;
            GetBody()->velocity.y = 0;
        }

        if(!mod(isnhit,3))
        {
            if(GetObject()->GetRender()->GetActivate())
                GetObject()->GetRender()->DeActivateRender();
            else
                GetObject()->GetRender()->ActivateRender();
        }

        ishurt --;
        isnhit --;
    }
    else //Sinon le joueur peut le controller
    {
        Object * Ennemi = GetObject()->GetObjectCollisionTag("Ennemis");
        Object * Boss = GetObject()->GetObjectCollisionTag("Boss");

        //Test de sui on touche un ennemi

        if(isnhit > 0)
        {
            isnhit --;

            if(!mod(isnhit,3))
            {
                if(GetObject()->GetRender()->GetActivate())
                    GetObject()->GetRender()->DeActivateRender();
                else
                    GetObject()->GetRender()->ActivateRender();
            }

            if(!isnhit)GetObject()->GetRender()->ActivateRender();
        }

        if(Ennemi)
        {
            GetEngine()->DelObject(Ennemi,true);

            if(!isaspi && !isnhit)
            {
                Interface->AddScore(400);

                if(GetIt() !=  12)
                {
                    isfull = 0;
                    ishurt = 20;
                    isnhit = 80;

                    Interface->DelVie(1);

                    if(Interface->GetVie() == 6 )ishurt = 0;
                }
            }
            else
            {
                if(isaspi)
                {
                    isfull = 2;
                    Interface->AddScore(200);
                }
            }

        }

        if(Boss && !isnhit)
        {
            isfull = 0;
            ishurt = 20;
            isnhit = 80;

            Interface->DelVie(1);

            if(Interface->GetVie() == 6 )ishurt = 0;
        }

        //Test de si kirby aspire

        if(input_press(K_OPTN) && !isfull)isaspi = true;
        if(input_release(K_OPTN) && !isfull || isfull)isaspi = false;

        if(isaspi)
        {
            OAspi->Enable();

            if(direction)
            {
                OAspi->GetTransform()->SetXY( GetX() - 40 , GetY());
                OAspi->GetRender()->ReverseRender(true);
            }
            else
            {
                OAspi->GetTransform()->SetXY( GetX() + 16 , GetY());
                OAspi->GetRender()->ReverseRender(false);
            }

            SetIt(3);

            isdo = true;
        }
        else
        {
            OAspi->Disable();

            if(input_trigger(K_OPTN))
            {
                SetIt(8);


                Object * Buffer = new Object;
                SSoufle * ScriptSouffle = new SSoufle;
                SStar * ScriptStar = new SStar;

                GetEngine()->AddObject(Buffer);

                if(!direction)
                {
                    Buffer->GetTransform()->SetXY( GetX() + 16 , GetY() + 8 );
                    Buffer->GetRender()->ReverseRender(false);
                }
                else
                {
                    Buffer->GetTransform()->SetXY( GetX(), GetY() + 8 );
                    Buffer->GetRender()->ReverseRender(true);
                }

                switch(isfull)
                {
                    case 1:
                        delete ScriptStar;

                        if(!couldown)
                        {
                            ScriptSouffle->time = 12;
                            ScriptSouffle->Interface = Interface;
                            Buffer->GetRender()->SetRender(RenderSouffle);
                            Buffer->AffectScript(ScriptSouffle);

                            ScriptSouffle->direction = direction;

                            couldown = 25;
                        }
                        else
                        {
                            delete ScriptSouffle;
                            GetEngine()->DelObject(Buffer);
                        }

                    break;
                    case 2:
                        delete ScriptSouffle;
                        ScriptStar->Interface = Interface;
                        Buffer->GetRender()->SetRender(RenderEtoile);
                        Buffer->AffectScript(ScriptStar);
                        Buffer->AddRigidBody();
                        Buffer->AffectTag("Star");

                        ScriptStar->direction = direction;
                    break;
                    default:

                        delete ScriptStar;
                        delete ScriptSouffle;
                        GetEngine()->DelObject(Buffer);
                    break;
                }


                isfull = 0;
                isdo = true;

                Buffer = NULL;
                ScriptSouffle = NULL;
                ScriptStar = NULL;
            }

            //Test des directions

            if(input_press(K_RIGHT))
            {
                Move( 1 + (isfull != 1) , 0 );
                direction = false;

                if(isfull)
                {
                    if(isground)SetIt(5);
                }
                else
                    SetIt(1);

                isdo = true;
            }
            else if(input_press(K_LEFT))
            {
                Move( - 1 - (isfull != 1) , 0 );
                direction = true;

                if(isfull)
                {
                    if(isground)SetIt(5);
                }
                else
                    SetIt(1);

                isdo = true;
            }

            //Test du saut

            if(input_trigger(K_SHIFT) && isground)
            {
                GetBody()->velocity.y = 42;

                if(isfull)
                    SetIt(6);
                else
                    SetIt(2);

                isdo = true;
            }

            //Test de l'accroupisement

            if(input_press(K_DOWN) && !isdo && !isfull)
            {
                SetIt(10);
                GetObject()->GetRigidBody()->UseFixeBody(16,8);
                isdo = true;
            }
            else
            {
                GetObject()->GetRigidBody()->UseFixeBody(16,16);
            }

            if(isfull)
            {
                if(!isground)
                {
                    if(GetObject()->GetRender()->GetIt() != 6 )SetIt(7);
                }
                else  if(!isdo)SetIt(4);
            }
            else
            {
                if(!isground)SetIt(2);
                else  if(!isdo)SetIt(0);
            }

            if(input_trigger(K_UP))
            {

                if(isfull == 1)
                {
                    GetBody()->velocity.y = 35;
                    SetIt(7);
                }

                if(!isfull)
                {
                    isfull = 1;
                    SetIt(9);
                }
                isdo = true;
            }

        }

    }

    GetObject()->GetRender()->ReverseRender(direction);

    if( GetY() < 3)
    {
        isfull = 0;
        Interface->DelVie(6);
        direction = false;
    }

    if(boss && GetX() > 160)
    {
        SetX(160);
    }

    if(GetObject()->GetCollisionTag("FS"))
    {
        Interface->AddScore(1000);
        Interface->EndStage();
    }

    if(!isfull && GetBody()->velocity.y < -40)SetIt(12);

    GetEngine()->MiddleScreen( GetX() + 8 , GetY() + 10 );

}

void Control::Initialisation(Animation E, Animation S , Object * A , Script_GUI * G)
{
    RenderEtoile = E;
    RenderSouffle = S;

    OAspi = A;

    Interface = G;
}

void Control::GenerateMonster()
{

    if(abs(oldx - GetX()) > 15 || abs(oldy - GetY()) > 15)
    {
        int sgnx = sgn(oldx - GetX());// Si 1 alors le perso se déplace vers la gauche Si -1 alors le perso se déplace vers la droite
        int sgny = sgn(oldy - GetY());// Si 1 alors le perso se déplace vers le bas Si -1 alors le perso se déplace vers le ha

        if(abs(oldx - GetX()) < 15)sgnx = 0;

        if(abs(oldx - GetY()) < 15)sgny = 0;

        int needground = true;

        oldx = GetX();
        oldy = GetY();

        if(!rand_int(4))// On détermine si il faut ou non faire poper un monstre. Le nombre diminue en fonction de la difficulté.
        {
            Object * Buffer = new Object;
            Buffer->AddRigidBody();
            Buffer->GetRigidBody()->SetMass(1);

            Mob_InLine * Buffer_Script1 = new Mob_InLine;
            Mob_Piaf * Buffer_Script2 = new Mob_Piaf;
            Mob_Champ * Buffer_Script3 = new Mob_Champ;
            Mob_InLine_Fly * Buffer_Script4 = new Mob_InLine_Fly;
            Mob_InLine * Buffer_Script5 = new Mob_InLine;
            Mob_InLine_Jump * Buffer_Script6 = new Mob_InLine_Jump;

            switch(rand_int(6))
            {
                case 0:

                    Buffer->GetRender()->CopieRender(AOurs);
                    if(sgnx == -1)
                        Buffer_Script1->SetDirection(true);
                    else
                        Buffer_Script1->SetDirection(false);

                    Buffer->AffectScript(Buffer_Script1);

                break;
                case 1:

                    Buffer->GetRender()->SetRender(APiaf,2);
                    needground = false;

                    if(sgnx == -1)
                        Buffer_Script2->SetDirection(true);
                    else
                        Buffer_Script2->SetDirection(false);

                    Buffer->AffectScript(Buffer_Script2);

                break;
                case 2:

                    Buffer->GetRender()->SetRender(AChamp,2);
                    Buffer->AffectScript(Buffer_Script3);

                break;
                case 3:

                    Buffer->GetRender()->CopieRender(AOupa);
                    needground = false;

                    if(sgnx == -1)
                        Buffer_Script4->SetDirection(true);
                    else
                        Buffer_Script4->SetDirection(false);

                    Buffer->AffectScript(Buffer_Script4);

                break;
                case 4:

                    Buffer->GetRender()->CopieRender(ABaby);



                    if(sgnx == -1)
                        Buffer_Script5->SetDirection(true);
                    else
                        Buffer_Script5->SetDirection(false);

                    Buffer->AffectScript(Buffer_Script5);

                break;
                case 5:

                    Buffer->GetRender()->CopieRender(AGhost);

                    if(sgnx == -1)
                        Buffer_Script6->SetDirection(true);
                    else
                        Buffer_Script6->SetDirection(false);

                    Buffer->AffectScript(Buffer_Script6);

                break;
                default:
                break;
            }

            if( Buffer_Script1 != Buffer->GetScript())delete Buffer_Script1;
            if( Buffer_Script2 != Buffer->GetScript())delete Buffer_Script2;
            if( Buffer_Script3 != Buffer->GetScript())delete Buffer_Script3;
            if( Buffer_Script4 != Buffer->GetScript())delete Buffer_Script4;
            if( Buffer_Script5 != Buffer->GetScript())delete Buffer_Script5;
            if( Buffer_Script6 != Buffer->GetScript())delete Buffer_Script6;


            GetEngine()->AddObject(Buffer);

            int end = 0;

            do
            {
                do
                {

                    do
                    {

                        Buffer->GetTransform()->SetXY( ((oldx - mod(oldx , 16))/16 + rand_int_ab( 8 , 12) * - sgnx ) * 16 , ((oldy - mod(oldy , 16))/16 + rand_int_ab( -2 , 6 ) * - sgny ) * 16 );
                        end ++;

                        if(end > 50)
                        {
                            GetEngine()->DelObject(Buffer);
                            return;
                        }
                    }
                    while( Buffer->IsOnScreen());

                }
                while( needground && ! Buffer->GetRigidBody()->CollisionDecor( Buffer->GetTransform()->GetX() , Buffer->GetTransform()->GetY() - 1) );

            }while( Buffer->GetRigidBody()->CollisionDecor( Buffer->GetTransform()->GetX() , Buffer->GetTransform()->GetY()) );


            Buffer->AffectTag("Ennemis");
            Buffer = NULL;

        }
    }
}

void SAspi::Update()
{
    Object * Buffer = NULL;

    Buffer = GetObject()->GetObjectCollisionTag("Ennemis");

    if( Buffer != NULL)
    {
        if(GetObject()->GetRender()->GetReverse()== false)
        {
            Buffer->GetRigidBody()->Move(-2,0);
        }
        else
        {
            Buffer->GetRigidBody()->Move(2,0);
        }
    }
}

void SSoufle::Update()
{
    if(time > 0)
    {
        if(direction)SetXY(  GetX() - 3 , GetY() );
        else SetXY(  GetX() + 3 , GetY() );
    }

    time--;

    Object * Buffer = GetObject()->GetObjectCollisionTag("Ennemis");

    if(Buffer != NULL)
    {
        GetEngine()->DelObject(Buffer,true);
        time = -11;

        Interface->AddScore(200);
        return;
    }

    if(time < -10)
    {
        GetEngine()->DelObject(GetObject());return;
    }

}

void SStar::Update()
{
    Object * Buffer = GetObject()->GetObjectCollisionTag("Ennemis");

    if(Buffer != NULL)
    {
        GetEngine()->DelObject(Buffer);
        SetXY(-50,-50);

        Interface->AddScore(400);

        return;
    }

    if(direction)
    {
        SetXY(  GetX() - 3 , GetY() );
        if(CollisionDecor(GetX() - 3 , GetY()))
        {
            GetEngine()->DelObject(GetObject());return;
        }
    }
    else
    {
        SetXY(  GetX() + 3 , GetY() );
        if(CollisionDecor(GetX() + 3 , GetY()))
        if(CollisionDecor(GetX() + 3 , GetY()))
        if(CollisionDecor(GetX() + 3 , GetY()))
        {
            GetEngine()->DelObject(GetObject());return;
        }
    }
}