Kirby: WaddleDoo

//---------------------------
// Includes
//---------------------------
#include "WaddleDoo.h"

//---------------------------
// Defines
//---------------------------
#define GAME_ENGINE (GameEngine::GetSingleton())

//---------------------------
// Constructor & Destructor
//---------------------------
Bitmap* WaddleDoo::m_BmpSpriteSheetPtr=nullptr;

WaddleDoo::WaddleDoo(int spawnX,int spawnY, int spawnFloor,int beginState):m_BeamLength(0),
    Enemy(spawnX,spawnY,spawnFloor,beginState)
{
    m_Power=POWER_BEAM;
    if(m_BmpSpriteSheetPtr==nullptr)
    {
        m_BmpSpriteSheetPtr= new Bitmap("./Resources/WaddleDooSpriteSheet.png");
        if(m_BmpSpriteSheetPtr->Exists())
        {
            m_BmpSpriteSheetPtr->SetTransparencyColor(185,220,255);
        }
    }

    m_BaseScore=3;
    // nothing to create
}

WaddleDoo::~WaddleDoo()
{

    // nothing to destroy
}

//---------------------------
// Own methods
//---------------------------

void WaddleDoo::Paint()
{
    if(m_Activated&&!m_Killed)
    {
        RECT ANIMATION;
        ANIMATION.bottom=0;
        ANIMATION.top=0;
        ANIMATION.left=0;
        ANIMATION.right=0;

        if(m_CurrentState==STATE_WALKING)
        {
            int tick=m_Tickcount%2;
            ANIMATION.left=tick*SIZE;
            ANIMATION.top=0;
            ANIMATION.bottom=SIZE;
            ANIMATION.right=ANIMATION.left+SIZE;
        }
        else if(m_CurrentState==STATE_PREPARINGATTACK)
        {
            int tick=m_Tickcount%2;

            ANIMATION.left=SIZE+tick*SIZE;
            ANIMATION.top=0;
            ANIMATION.bottom=SIZE;
            ANIMATION.right=ANIMATION.left+SIZE;
        }
        else if(m_CurrentState==STATE_ATTACK)
        {
            int tick=m_Tickcount%1;

            ANIMATION.left=0;
            ANIMATION.top=0;
            ANIMATION.bottom=SIZE;
            ANIMATION.right=ANIMATION.left+SIZE;
        }
        else if(m_CurrentState==STATE_JUMP)
        {
            ANIMATION.left=0;
            ANIMATION.top=0;
            ANIMATION.bottom=SIZE;
            ANIMATION.right=ANIMATION.left+SIZE;
        }

        GAME_ENGINE->DrawBitmap(m_BmpSpriteSheetPtr,0,HEIGHTBITMAP,ANIMATION);

        if(m_CurrentState==STATE_ATTACK)
        {
            int tick=m_Tickcount%4;
            ANIMATION.top=86;
            ANIMATION.left=16*tick;
            ANIMATION.right=ANIMATION.left+16;
            ANIMATION.bottom=ANIMATION.top+16;
            for (int i = 0; i < AMOUNTOFBEAM; i++)
            {
                GAME_ENGINE->DrawBitmap(m_BmpAttackSpriteSheetPtr,(int)m_BeamCoordArr[i].x+36,(int)m_BeamCoordArr[i].y+12,ANIMATION);
            }
        }
    }
}

void WaddleDoo::AI(double deltaTime,int gravity, double x)
{
    if(m_AttackOnePtr->IsPlaying())
    {
        if(!(m_CurrentState==STATE_ATTACK))
        {
            m_AttackOnePtr->Stop();
            m_AttackOnePtr->Tick();
        }
    }
    switch (m_CurrentState)
    {
        case STATE_WALKING:
            if(m_Delay==0)m_Tickcount++;
            m_Tickcount=m_Tickcount%4;
            break;
        case STATE_PREPARINGATTACK:
            if(m_Delay==0)m_Tickcount++;
            if(m_Tickcount>=10)
            {
                m_Tickcount=0;
                m_Delay=1;
                m_BeamLength=0;
                m_CurrentState=STATE_ATTACK;
                BeamGenerator(0);
            }
            break;
        case STATE_ATTACK:
            if(!(m_AttackOnePtr->IsPlaying()))
            {
                m_AttackOnePtr->Play();
                m_AttackOnePtr->Tick();
            }
            if(m_Delay==0)m_Tickcount++;
            if(m_BeamLength>=0.5)
            {
                m_Tickcount=0;
                m_Delay=1;
                m_CurrentState=STATE_WALKING;
            }
            break;
        case STATE_JUMP:
            if(m_HitFloorWall)
            {
                m_Tickcount=0;
                m_Delay=1;
                m_CurrentState=STATE_WALKING;
            }
            else
            {
                if(m_AllRight)
                {
                    m_Velocity.x=SPEEDJUMP;
                }
                else m_Velocity.x=-SPEEDJUMP;
            }
    default:
        break;
    }

    if(m_CurrentState==STATE_WALKING)
    {
        if(m_HitLeftWall)m_AllRight=true;
        else if(m_HitRightWall)m_AllRight=false;
        if(m_AllRight)
        {
            m_Velocity.x=SPEED;
        }
        else m_Velocity.x=-SPEED;
    }

    if(m_CurrentState==STATE_ATTACK)
    {
        BeamGenerator(deltaTime);
    }
    Gravity(deltaTime,gravity);
}

void WaddleDoo::BeamGenerator(double deltaTime)
{
    for (int i = 0; i < AMOUNTOFBEAM; i++)
    {
        m_BeamCoordArr[i].x=(80*i/AMOUNTOFBEAM)*cos(6*m_BeamLength-(M_PI/2));
        m_BeamCoordArr[i].y=(80*i/AMOUNTOFBEAM)*sin(6*m_BeamLength-(M_PI/2));
    }
    m_BeamLength+=deltaTime;
}

bool WaddleDoo::IsBeamAttack()
{
    if(m_CurrentState==STATE_ATTACK)return true;
    else return false;
}

DOUBLE2 WaddleDoo::GetBeamCoords(bool vector)
{
    DOUBLE2 beam;

    if(vector)
    {
        beam=m_BeamCoordArr[AMOUNTOFBEAM-1];
        if(!m_AllRight)beam.x*=-1;
    }
    else
    {
        if(m_AllRight)beam.x=m_Coordinates.x+43,beam.y=m_Coordinates.y+19;
        else beam.x=m_Coordinates.x-14,beam.y=m_Coordinates.y+19;
    }

    return beam;
}

void WaddleDoo::HeroCertainDistance(DOUBLE2 heroCoordinates)
{
    if(m_CurrentState==STATE_WALKING)
    {
        int random=rand()%100;
        if(abs(heroCoordinates.x-m_Coordinates.x)<100)
        {
            int random=rand()%10;
            if(random==0)
            {
                m_CurrentState=STATE_JUMP;
                m_Tickcount=0;
                m_Delay=1;
                m_Coordinates.y-=2;
                m_Velocity.y=-JUMP;
                m_HitFloorWall=false;
            }
            else
            {
                m_CurrentState=STATE_PREPARINGATTACK;
                m_Tickcount=0;
                m_Delay=1;
            }
        }
    }
}